def findThreshold(scenario,t,model='powell',position=0): """ Finds the threshold at which the agent will accept the offer""" if model == 'slantchev': # Find counteroffer in this state actions = [] while len(actions) < 2: world = World(scenario) world.setState(None,'round',t) world.setState('Freedonia','position',position) entry = {} scenarioSimulationUseCase(world,20,2,entry,model) actions = entry[20].getvalue().split('\n')[:-1] entry[20].close() amount = int(actions[1].split('-')[-1]) print 'Time: %d, Position %d -> Offer %d%%' % (t,position,amount) # Compute acceptance threshold offers = [50] index = 0 entry = {} while True: world = World(scenario) world.setState(None,'round',t) if model == 'slantchev': world.setState('Freedonia','position',position) scenarioSimulationUseCase(world,offers[index],1,entry,model) actions = entry[offers[index]].getvalue().split('\n')[:-1] entry[offers[index]].close() entry[offers[index]] = actions[0].split('-')[1].split()[0] if entry[offers[index]] == 'accept': # Try a lower offer if index > 0: down = offers[index-1] assert entry[down] != 'accept' else: down = 0 new = (offers[index]+down) / 2 if entry.has_key(new): if entry[new] != 'accept': new += 1 break else: offers.insert(index,new) else: assert entry[offers[index]] in ['reject','attack'] # Try a higher offer try: up = offers[index+1] assert entry[up] == 'accept' except IndexError: up = 100 new = (offers[index]+up) / 2 if entry.has_key(new): break else: offers.insert(index+1,new) index += 1 return new
def findThreshold(scenario, t, model='powell', position=0): """ Finds the threshold at which the agent will accept the offer""" if model == 'slantchev': # Find counteroffer in this state actions = [] while len(actions) < 2: world = World(scenario) world.setState(None, 'round', t) world.setState('Freedonia', 'position', position) entry = {} scenarioSimulationUseCase(world, 20, 2, entry, model) actions = entry[20].getvalue().split('\n')[:-1] entry[20].close() amount = int(actions[1].split('-')[-1]) print 'Time: %d, Position %d -> Offer %d%%' % (t, position, amount) # Compute acceptance threshold offers = [50] index = 0 entry = {} while True: world = World(scenario) world.setState(None, 'round', t) if model == 'slantchev': world.setState('Freedonia', 'position', position) scenarioSimulationUseCase(world, offers[index], 1, entry, model) actions = entry[offers[index]].getvalue().split('\n')[:-1] entry[offers[index]].close() entry[offers[index]] = actions[0].split('-')[1].split()[0] if entry[offers[index]] == 'accept': # Try a lower offer if index > 0: down = offers[index - 1] assert entry[down] != 'accept' else: down = 0 new = (offers[index] + down) / 2 if entry.has_key(new): if entry[new] != 'accept': new += 1 break else: offers.insert(index, new) else: assert entry[offers[index]] in ['reject', 'attack'] # Try a higher offer try: up = offers[index + 1] assert entry[up] == 'accept' except IndexError: up = 100 new = (offers[index] + up) / 2 if entry.has_key(new): break else: offers.insert(index + 1, new) index += 1 return new
def scenarioCreationUseCase(enemy='Sylvania', model='powell', web=False, fCollapse=None, sCollapse=None, maxRounds=15): """ An example of how to create a scenario @param enemy: the name of the agent-controlled side, i.e., Freedonia's opponent (default: Sylvania) @type enemy: str @param model: which model do we use (default is "powell") @type model: powell or slantchev @param web: if C{True}, then create the web-based experiment scenario (default: C{False}) @type web: bool @param fCollapse: the probability that Freedonia collapses (under powell, default: 0.1) or loses battle (under slantchev, default: 0.7) @type fCollapse: float @param sCollapse: the probability that Sylvania collapses, under powell (default: 0.1) @type sCollapse: float @param maxRounds: the maximum number of game rounds (default: 15) @type maxRounds: int @return: the scenario created @rtype: L{World} """ # Handle defaults for battle probabilities, under each model posLo = 0 posHi = 10 if fCollapse is None: if model == 'powell': fCollapse = 0.1 elif model == 'slantchev': fCollapse = 0.7 if sCollapse is None: sCollapse = 0.1 # Create scenario world = World() # Agents free = Agent('Freedonia') world.addAgent(free) sylv = Agent(enemy) world.addAgent(sylv) # User state world.defineState(free.name, 'troops', int, lo=0, hi=50000, description='Number of troops you have left') free.setState('troops', 40000) world.defineState( free.name, 'territory', int, lo=0, hi=100, description='Percentage of disputed territory owned by you') free.setState('territory', 15) world.defineState(free.name, 'cost', int, lo=0, hi=50000, description='Number of troops %s loses in an attack' % (free.name)) free.setState('cost', 2000) world.defineState( free.name, 'position', int, lo=posLo, hi=posHi, description='Current status of war (%d=%s is winner, %d=you are winner)' % (posLo, sylv.name, posHi)) free.setState('position', 5) world.defineState( free.name, 'offered', int, lo=0, hi=100, description= 'Percentage of disputed territory that %s last offered to you' % (sylv.name)) free.setState('offered', 0) if model == 'slantchev': # Compute new value for territory only *after* computing new value for position world.addDependency(stateKey(free.name, 'territory'), stateKey(free.name, 'position')) # Agent state world.defineState(sylv.name, 'troops', int, lo=0, hi=500000, description='Number of troops %s has left' % (sylv.name)) sylv.setState('troops', 30000) world.defineState(sylv.name, 'cost', int, lo=0, hi=50000, description='Number of troops %s loses in an attack' % (sylv.name)) sylv.setState('cost', 2000) world.defineState( sylv.name, 'offered', int, lo=0, hi=100, description= 'Percentage of disputed territory that %s last offered to %s' % (free.name, sylv.name)) sylv.setState('offered', 0) # World state world.defineState(None, 'treaty', bool, description='Have the two sides reached an agreement?') world.setState(None, 'treaty', False) # Stage of negotiation, illustrating the use of an enumerated state feature world.defineState( None, 'phase', list, ['offer', 'respond', 'rejection', 'end', 'paused', 'engagement'], description='The current stage of the negotiation game') world.setState(None, 'phase', 'paused') # Game model, static descriptor world.defineState(None, 'model', list, ['powell', 'slantchev'], description='The model underlying the negotiation game') world.setState(None, 'model', model) # Round of negotiation world.defineState(None, 'round', int, description='The current round of the negotiation') world.setState(None, 'round', 0) if not web: # Relationship value key = world.defineRelation(free.name, sylv.name, 'trusts') world.setFeature(key, 0.) # Game over if there is a treaty world.addTermination( makeTree({ 'if': trueRow(stateKey(None, 'treaty')), True: True, False: False })) # Game over if Freedonia has no territory world.addTermination( makeTree({ 'if': thresholdRow(stateKey(free.name, 'territory'), 1), True: False, False: True })) # Game over if Freedonia has all the territory world.addTermination( makeTree({ 'if': thresholdRow(stateKey(free.name, 'territory'), 99), True: True, False: False })) # Game over if number of rounds exceeds limit world.addTermination( makeTree({ 'if': thresholdRow(stateKey(None, 'round'), maxRounds), True: True, False: False })) # Turn order: Uncomment the following if you want agents to act in parallel # world.setOrder([set(world.agents.keys())]) # Turn order: Uncomment the following if you want agents to act sequentially world.setOrder([free.name, sylv.name]) # User actions freeBattle = free.addAction({'verb': 'attack', 'object': sylv.name}) for amount in range(20, 100, 20): free.addAction({ 'verb': 'offer', 'object': sylv.name, 'amount': amount }) if model == 'powell': # Powell has null stages freeNOP = free.addAction({'verb': 'continue'}) elif model == 'slantchev': # Slantchev has both sides receiving offers free.addAction({'verb': 'accept offer', 'object': sylv.name}) free.addAction({'verb': 'reject offer', 'object': sylv.name}) # Agent actions sylvBattle = sylv.addAction({'verb': 'attack', 'object': free.name}) sylvAccept = sylv.addAction({'verb': 'accept offer', 'object': free.name}) sylvReject = sylv.addAction({'verb': 'reject offer', 'object': free.name}) if model == 'powell': # Powell has null stages sylvNOP = sylv.addAction({'verb': 'continue'}) elif model == 'slantchev': # Slantchev has both sides making offers for amount in range(10, 100, 10): sylv.addAction({ 'verb': 'offer', 'object': free.name, 'amount': amount }) # Restrictions on when actions are legal, based on phase of game for action in filterActions({'verb': 'offer'}, free.actions | sylv.actions): agent = world.agents[action['subject']] agent.setLegal( action, makeTree({ 'if': equalRow(stateKey(None, 'phase'), 'offer'), True: True, # Offers are legal in the offer phase False: False })) # Offers are illegal in all other phases if model == 'powell': # Powell has a special rejection phase for action in [freeNOP, freeBattle]: free.setLegal( action, makeTree({ 'if': equalRow(stateKey(None, 'phase'), 'rejection'), True: True, # Attacking and doing nothing are legal only in rejection phase False: False }) ) # Attacking and doing nothing are illegal in all other phases # Once offered, agent can respond if model == 'powell': # Under Powell, only Sylvania has to respond, and it can attack responses = [sylvBattle, sylvAccept, sylvReject] elif model == 'slantchev': # Under Slantchev, only accept/reject responses = filterActions({'verb': 'accept offer'}, free.actions | sylv.actions) responses += filterActions({'verb': 'reject offer'}, free.actions | sylv.actions) for action in responses: agent = world.agents[action['subject']] agent.setLegal( action, makeTree({ 'if': equalRow(stateKey(None, 'phase'), 'respond'), True: True, # Offeree must act in the response phase False: False })) # Offeree cannot act in any other phase if model == 'powell': # NOP is legal in exactly opposite situations to all other actions sylv.setLegal( sylvNOP, makeTree({ 'if': equalRow(stateKey(None, 'phase'), 'end'), True: True, # Sylvania does not do anything in the null phase after Freedonia responds to rejection False: False })) # Sylvania must act in its other phases if model == 'slantchev': # Attacking legal only under engagement phase for action in filterActions({'verb': 'attack'}, free.actions | sylv.actions): agent = world.agents[action['subject']] agent.setLegal( action, makeTree({ 'if': equalRow(stateKey(None, 'phase'), 'engagement'), True: True, # Attacking legal only in engagement False: False })) # Attacking legal every other phase # Goals for Freedonia goalFTroops = maximizeFeature(stateKey(free.name, 'troops')) free.setReward(goalFTroops, 1.) goalFTerritory = maximizeFeature(stateKey(free.name, 'territory')) free.setReward(goalFTerritory, 1.) # Goals for Sylvania goalSTroops = maximizeFeature(stateKey(sylv.name, 'troops')) sylv.setReward(goalSTroops, 1.) goalSTerritory = minimizeFeature(stateKey(free.name, 'territory')) sylv.setReward(goalSTerritory, 1.) # Possible goals applicable to both goalAgreement = maximizeFeature(stateKey(None, 'treaty')) # Silly goal, provided as an example of an achievement goal goalAchieve = achieveFeatureValue(stateKey(None, 'phase'), 'respond') # Horizons if model == 'powell': free.setAttribute('horizon', 4) sylv.setAttribute('horizon', 4) elif model == 'slantchev': free.setAttribute('horizon', 6) sylv.setAttribute('horizon', 6) # Discount factors free.setAttribute('discount', -1) sylv.setAttribute('discount', -1) # Levels of belief free.setRecursiveLevel(2) sylv.setRecursiveLevel(2) # Dynamics of battle freeTroops = stateKey(free.name, 'troops') freeTerr = stateKey(free.name, 'territory') sylvTroops = stateKey(sylv.name, 'troops') # Effect of fighting for action in filterActions({'verb': 'attack'}, free.actions | sylv.actions): # Effect on troops (cost of battle) tree = makeTree( addFeatureMatrix(freeTroops, stateKey(free.name, 'cost'), -1.)) world.setDynamics(freeTroops, action, tree, enforceMin=not web) tree = makeTree( addFeatureMatrix(sylvTroops, stateKey(sylv.name, 'cost'), -1.)) world.setDynamics(sylvTroops, action, tree, enforceMin=not web) if model == 'powell': # Effect on territory (probability of collapse) tree = makeTree({ 'distribution': [ ( { 'distribution': [ (setToConstantMatrix(freeTerr, 100), 1. - fCollapse ), # Sylvania collapses, Freedonia does not (noChangeMatrix(freeTerr), fCollapse) ] }, # Both collapse sCollapse), ( { 'distribution': [ (setToConstantMatrix(freeTerr, 0), fCollapse ), # Freedonia collapses, Sylvania does not (noChangeMatrix(freeTerr), 1. - fCollapse) ] }, # Neither collapses 1. - sCollapse) ] }) world.setDynamics(freeTerr, action, tree) elif model == 'slantchev': # Effect on position pos = stateKey(free.name, 'position') tree = makeTree({ 'distribution': [ (incrementMatrix(pos, 1), 1. - fCollapse), # Freedonia wins battle (incrementMatrix(pos, -1), fCollapse) ] }) # Freedonia loses battle world.setDynamics(pos, action, tree) # Effect on territory tree = makeTree({ 'if': thresholdRow(pos, posHi - .5), True: setToConstantMatrix(freeTerr, 100), # Freedonia won False: { 'if': thresholdRow(pos, posLo + .5), True: noChangeMatrix(freeTerr), False: setToConstantMatrix(freeTerr, 0) } }) # Freedonia lost world.setDynamics(freeTerr, action, tree) # Dynamics of offers for index in range(2): atom = Action({ 'subject': world.agents.keys()[index], 'verb': 'offer', 'object': world.agents.keys()[1 - index] }) if atom['subject'] == free.name or model != 'powell': offer = stateKey(atom['object'], 'offered') amount = actionKey('amount') tree = makeTree({ 'if': trueRow(stateKey(None, 'treaty')), True: noChangeMatrix(offer), False: setToConstantMatrix(offer, amount) }) world.setDynamics(offer, atom, tree, enforceMax=not web) # Dynamics of treaties for action in filterActions({'verb': 'accept offer'}, free.actions | sylv.actions): # Accepting an offer means that there is now a treaty key = stateKey(None, 'treaty') tree = makeTree(setTrueMatrix(key)) world.setDynamics(key, action, tree) # Accepting offer sets territory offer = stateKey(action['subject'], 'offered') territory = stateKey(free.name, 'territory') if action['subject'] == free.name: # Freedonia accepts sets territory to last offer tree = makeTree(setToFeatureMatrix(territory, offer)) world.setDynamics(freeTerr, action, tree) else: # Sylvania accepts sets territory to 1-last offer tree = makeTree( setToFeatureMatrix(territory, offer, pct=-1., shift=100.)) world.setDynamics(freeTerr, action, tree) # Dynamics of phase phase = stateKey(None, 'phase') roundKey = stateKey(None, 'round') # OFFER -> RESPOND for index in range(2): action = Action({ 'subject': world.agents.keys()[index], 'verb': 'offer', 'object': world.agents.keys()[1 - index] }) if action['subject'] == free.name or model != 'powell': tree = makeTree(setToConstantMatrix(phase, 'respond')) world.setDynamics(phase, action, tree) # RESPOND -> REJECTION or ENGAGEMENT for action in filterActions({'verb': 'reject offer'}, free.actions | sylv.actions): if model == 'powell': tree = makeTree(setToConstantMatrix(phase, 'rejection')) elif model == 'slantchev': tree = makeTree(setToConstantMatrix(phase, 'engagement')) world.setDynamics(phase, action, tree) # accepting -> OFFER for action in filterActions({'verb': 'accept offer'}, free.actions | sylv.actions): tree = makeTree(setToConstantMatrix(phase, 'offer')) world.setDynamics(phase, action, tree) # attacking -> OFFER for action in filterActions({'verb': 'attack'}, free.actions | sylv.actions): tree = makeTree(setToConstantMatrix(phase, 'offer')) world.setDynamics(phase, action, tree) if action['subject'] == sylv.name or model == 'slantchev': tree = makeTree(incrementMatrix(roundKey, 1)) world.setDynamics(roundKey, action, tree) if model == 'powell': # REJECTION -> END for atom in [freeNOP, freeBattle]: tree = makeTree(setToConstantMatrix(phase, 'end')) world.setDynamics(phase, atom, tree) # END -> OFFER atom = Action({'subject': sylv.name, 'verb': 'continue'}) tree = makeTree(setToConstantMatrix(phase, 'offer')) world.setDynamics(phase, atom, tree) tree = makeTree(incrementMatrix(roundKey, 1)) world.setDynamics(roundKey, atom, tree) if not web: # Relationship dynamics: attacking is bad for trust atom = Action({ 'subject': sylv.name, 'verb': 'attack', 'object': free.name }) key = binaryKey(free.name, sylv.name, 'trusts') tree = makeTree(approachMatrix(key, 0.1, -1.)) world.setDynamics(key, atom, tree) # Handcrafted policy for Freedonia # free.setPolicy(makeTree({'if': equalRow('phase','respond'), # # Accept an offer greater than 50 # True: {'if': thresholdRow(stateKey(free.name,'offered'),50), # True: Action({'subject': free.name,'verb': 'accept offer','object': sylv.name}), # False: Action({'subject': free.name,'verb': 'reject offer','object': sylv.name})}, # False: {'if': equalRow('phase','engagement'), # # Attack during engagement phase # True: Action({'subject': free.name,'verb': 'attack','object': sylv.name}), # # Agent decides how what to do otherwise # False: False}})) # Mental models of enemy # Example of creating a model with incorrect reward all at once (a version of Freedonia who cares about reaching agreement as well) # sylv.addModel('false',R={goalSTroops: 10.,goalSTerritory: 1.,goalAgreement: 1.}, # rationality=1.,selection='distribution',parent=True) # Example of creating a model with incorrect beliefs sylv.addModel('false', rationality=10., selection='distribution', parent=True) key = stateKey(free.name, 'position') # Sylvania believes position to be fixed at 3 sylv.setBelief(key, 3, 'false') # Freedonia is truly unsure about position (50% chance of being 7, 50% of being 3) world.setModel(free.name, True) free.setBelief(key, Distribution({7: 0.5, 3: 0.5}), True) # Observations about military position tree = makeTree({ 'if': thresholdRow(key, 1), True: { 'if': thresholdRow(key, 9), True: { 'distribution': [(KeyedVector({key: 1}), 0.9), (KeyedVector({ key: 1, CONSTANT: -1 }), 0.1)] }, False: { 'distribution': [(KeyedVector({key: 1}), 0.8), (KeyedVector({ key: 1, CONSTANT: -1 }), 0.1), (KeyedVector({ key: 1, CONSTANT: 1 }), 0.1)] } }, False: { 'distribution': [(KeyedVector({key: 1}), 0.9), (KeyedVector({ key: 1, CONSTANT: 1 }), 0.1)] } }) free.defineObservation(key, tree) # Example of setting model parameters separately sylv.addModel('true', parent=True) sylv.setAttribute( 'rationality', 10., 'true') # Override real agent's rationality with this value sylv.setAttribute('selection', 'distribution', 'true') world.setMentalModel(free.name, sylv.name, {'false': 0.9, 'true': 0.1}) # Goal of fooling Sylvania goalDeception = achieveFeatureValue(modelKey(sylv.name), sylv.model2index('false')) return world
class Centipede: def __init__(self, turnOrder, maxRounds, payoff): self.maxRounds = maxRounds self.payoff = payoff print self.payoff self.world = World() stacy = Agent('Stacy') david = Agent('David') agts = [stacy, david] # Player state, actions and parameters common to both players for i in range(2): me = agts[i] other = agts[1 - i] self.world.addAgent(me) # State self.world.defineState(me.name, 'money', int) me.setState('money', 0) mePass = me.addAction({'verb': 'pass', 'object': other.name}) meTake = me.addAction({'verb': 'take', 'object': other.name}) # Parameters me.setHorizon(6) me.setParameter('discount', 1.) # me.setParameter('discount',0.9) # Levels of belief david.setRecursiveLevel(3) stacy.setRecursiveLevel(3) self.world.setOrder(turnOrder) # World state self.world.defineState(None, 'round', int, description='The current round') self.world.setState(None, 'round', 0) self.world.defineState(None, 'gameOver', bool, description='whether game is over') self.world.setState(None, 'gameOver', False) self.world.addTermination( makeTree({ 'if': thresholdRow(stateKey(None, 'round'), self.maxRounds), True: True, False: { 'if': trueRow(stateKey(None, 'gameOver')), True: True, False: False } })) # Dynamics for action in stacy.actions | david.actions: tree = makeTree(incrementMatrix(stateKey(None, 'round'), 1)) self.world.setDynamics(None, 'round', action, tree) if (action['verb'] == 'take'): tree = makeTree(setTrueMatrix(stateKey(None, 'gameOver'))) self.world.setDynamics(None, 'gameOver', action, tree) agts = ['Stacy', 'David'] for i in range(2): key = stateKey(agts[i], 'money') tree = makeTree( self.buildPayoff(0, key, self.payoff[agts[i]])) self.world.setDynamics(agts[i], 'money', action, tree) elif action['verb'] == 'pass': agts = ['Stacy', 'David'] for i in range(2): key = stateKey(agts[i], 'money') tree = makeTree({ 'if': equalRow(stateKey(None, 'round'), self.maxRounds - 1), True: setToConstantMatrix( key, self.payoff[agts[i]][self.maxRounds]), False: noChangeMatrix(key) }) self.world.setDynamics(agts[i], 'money', action, tree) # really need to ask david about these levels - if adding modesl with levels, can # the true model point to these but have a different level for agent in self.world.agents.values(): agent.addModel('Christian', R={}, level=2, rationality=10., selection='distribution') agent.addModel('Capitalist', R={}, level=2, rationality=10., selection='distribution') # agent.addModel('Christian',R={},level=2,rationality=0.01) # agent.addModel('Capitalist',R={},level=2,rationality=0.01) def buildPayoff(self, rnd, key, payoff): if (rnd == self.maxRounds - 1): return setToConstantMatrix(key, payoff[rnd]) else: return { 'if': equalRow(stateKey(None, 'round'), rnd), True: setToConstantMatrix(key, payoff[rnd]), False: self.buildPayoff(rnd + 1, key, payoff) } def modeltest(self, trueModels, davidBeliefAboutStacy, stacyBeliefAboutDavid, strongerBelief): agts = self.world.agents.values() for i in range(2): me = agts[i] other = agts[1 - i] for model in me.models.keys(): if model is True: name = trueModels[me.name] else: name = model if name == 'Capitalist': me.setReward(maximizeFeature(stateKey(me.name, 'money')), 1.0, model) elif name == 'Christian': me.setReward(maximizeFeature(stateKey(me.name, 'money')), 1.0, model) me.setReward( maximizeFeature(stateKey(other.name, 'money')), 1.0, model) weakBelief = 1.0 - strongerBelief belief = {'Christian': weakBelief, 'Capitalist': weakBelief} belief[davidBeliefAboutStacy] = strongerBelief self.world.setMentalModel('David', 'Stacy', belief) belief = {'Christian': weakBelief, 'Capitalist': weakBelief} belief[stacyBeliefAboutDavid] = strongerBelief self.world.setMentalModel('Stacy', 'David', belief) def runit(self, Msg): print Msg for t in range(self.maxRounds + 1): self.world.explain(self.world.step(), level=2) # self.world.explain(self.world.step(),level=1) # print self.world.step() self.world.state.select() # self.world.printState() if self.world.terminated(): break
# Parameters me.setHorizon(6) me.setParameter('discount',0.9) # Levels of belief david.setRecursiveLevel(3) stacy.setRecursiveLevel(3) # Turn order: Uncomment the following if you want agents to act in parallel #world.setOrder([{agts[0].name,agts[1].name}]) # Turn order: Uncomment the following if you want agents to act sequentially world.setOrder([agts[0].name,agts[1].name]) # World state world.defineState(None,'agreement',bool) world.setState(None,'agreement',False) world.defineState(None,'appleOffer',bool) world.setState(None,'appleOffer',False) world.defineState(None,'pearOffer',bool) world.setState(None,'pearOffer',False) world.defineState(None,'round',int,description='The current round of the negotiation') world.setState(None,'round',0) world.defineState(None,'rejectedNegotiation',bool, description='Have one of the players walked out?') world.setState(None, 'rejectedNegotiation', False) # dont terminate so agent sees benefit of early agreement # world.addTermination(makeTree({'if': trueRow(stateKey(None,'agreement')), # True: True, # False: False}))
def scenarioCreationUseCase(enemy='Sylvania',model='powell',web=False, fCollapse=None,sCollapse=None,maxRounds=15): """ An example of how to create a scenario @param enemy: the name of the agent-controlled side, i.e., Freedonia's opponent (default: Sylvania) @type enemy: str @param model: which model do we use (default is "powell") @type model: powell or slantchev @param web: if C{True}, then create the web-based experiment scenario (default: C{False}) @type web: bool @param fCollapse: the probability that Freedonia collapses (under powell, default: 0.1) or loses battle (under slantchev, default: 0.7) @type fCollapse: float @param sCollapse: the probability that Sylvania collapses, under powell (default: 0.1) @type sCollapse: float @param maxRounds: the maximum number of game rounds (default: 15) @type maxRounds: int @return: the scenario created @rtype: L{World} """ # Handle defaults for battle probabilities, under each model posLo = 0 posHi = 10 if fCollapse is None: if model == 'powell': fCollapse = 0.1 elif model == 'slantchev': fCollapse = 0.7 if sCollapse is None: sCollapse = 0.1 # Create scenario world = World() # Agents free = Agent('Freedonia') world.addAgent(free) sylv = Agent(enemy) world.addAgent(sylv) # User state world.defineState(free.name,'troops',int,lo=0,hi=50000, description='Number of troops you have left') free.setState('troops',40000) world.defineState(free.name,'territory',int,lo=0,hi=100, description='Percentage of disputed territory owned by you') free.setState('territory',15) world.defineState(free.name,'cost',int,lo=0,hi=50000, description='Number of troops %s loses in an attack' % (free.name)) free.setState('cost',2000) world.defineState(free.name,'position',int,lo=posLo,hi=posHi, description='Current status of war (%d=%s is winner, %d=you are winner)' % (posLo,sylv.name,posHi)) free.setState('position',5) world.defineState(free.name,'offered',int,lo=0,hi=100, description='Percentage of disputed territory that %s last offered to you' % (sylv.name)) free.setState('offered',0) if model == 'slantchev': # Compute new value for territory only *after* computing new value for position world.addDependency(stateKey(free.name,'territory'),stateKey(free.name,'position')) # Agent state world.defineState(sylv.name,'troops',int,lo=0,hi=500000, description='Number of troops %s has left' % (sylv.name)) sylv.setState('troops',30000) world.defineState(sylv.name,'cost',int,lo=0,hi=50000, description='Number of troops %s loses in an attack' % (sylv.name)) sylv.setState('cost',2000) world.defineState(sylv.name,'offered',int,lo=0,hi=100, description='Percentage of disputed territory that %s last offered to %s' % (free.name,sylv.name)) sylv.setState('offered',0) # World state world.defineState(None,'treaty',bool, description='Have the two sides reached an agreement?') world.setState(None,'treaty',False) # Stage of negotiation, illustrating the use of an enumerated state feature world.defineState(None,'phase',list,['offer','respond','rejection','end','paused','engagement'], description='The current stage of the negotiation game') world.setState(None,'phase','paused') # Game model, static descriptor world.defineState(None,'model',list,['powell','slantchev'], description='The model underlying the negotiation game') world.setState(None,'model',model) # Round of negotiation world.defineState(None,'round',int,description='The current round of the negotiation') world.setState(None,'round',0) if not web: # Relationship value key = world.defineRelation(free.name,sylv.name,'trusts') world.setFeature(key,0.) # Game over if there is a treaty world.addTermination(makeTree({'if': trueRow(stateKey(None,'treaty')), True: True, False: False})) # Game over if Freedonia has no territory world.addTermination(makeTree({'if': thresholdRow(stateKey(free.name,'territory'),1), True: False, False: True}) ) # Game over if Freedonia has all the territory world.addTermination(makeTree({'if': thresholdRow(stateKey(free.name,'territory'),99), True: True, False: False})) # Game over if number of rounds exceeds limit world.addTermination(makeTree({'if': thresholdRow(stateKey(None,'round'),maxRounds), True: True, False: False})) # Turn order: Uncomment the following if you want agents to act in parallel # world.setOrder([set(world.agents.keys())]) # Turn order: Uncomment the following if you want agents to act sequentially world.setOrder([free.name,sylv.name]) # User actions freeBattle = free.addAction({'verb': 'attack','object': sylv.name}) for amount in range(20,100,20): free.addAction({'verb': 'offer','object': sylv.name,'amount': amount}) if model == 'powell': # Powell has null stages freeNOP = free.addAction({'verb': 'continue'}) elif model == 'slantchev': # Slantchev has both sides receiving offers free.addAction({'verb': 'accept offer','object': sylv.name}) free.addAction({'verb': 'reject offer','object': sylv.name}) # Agent actions sylvBattle = sylv.addAction({'verb': 'attack','object': free.name}) sylvAccept = sylv.addAction({'verb': 'accept offer','object': free.name}) sylvReject = sylv.addAction({'verb': 'reject offer','object': free.name}) if model == 'powell': # Powell has null stages sylvNOP = sylv.addAction({'verb': 'continue'}) elif model == 'slantchev': # Slantchev has both sides making offers for amount in range(10,100,10): sylv.addAction({'verb': 'offer','object': free.name,'amount': amount}) # Restrictions on when actions are legal, based on phase of game for action in filterActions({'verb': 'offer'},free.actions | sylv.actions): agent = world.agents[action['subject']] agent.setLegal(action,makeTree({'if': equalRow(stateKey(None,'phase'),'offer'), True: True, # Offers are legal in the offer phase False: False})) # Offers are illegal in all other phases if model == 'powell': # Powell has a special rejection phase for action in [freeNOP,freeBattle]: free.setLegal(action,makeTree({'if': equalRow(stateKey(None,'phase'),'rejection'), True: True, # Attacking and doing nothing are legal only in rejection phase False: False})) # Attacking and doing nothing are illegal in all other phases # Once offered, agent can respond if model == 'powell': # Under Powell, only Sylvania has to respond, and it can attack responses = [sylvBattle,sylvAccept,sylvReject] elif model == 'slantchev': # Under Slantchev, only accept/reject responses = filterActions({'verb': 'accept offer'},free.actions | sylv.actions) responses += filterActions({'verb': 'reject offer'},free.actions | sylv.actions) for action in responses: agent = world.agents[action['subject']] agent.setLegal(action,makeTree({'if': equalRow(stateKey(None,'phase'),'respond'), True: True, # Offeree must act in the response phase False: False})) # Offeree cannot act in any other phase if model == 'powell': # NOP is legal in exactly opposite situations to all other actions sylv.setLegal(sylvNOP,makeTree({'if': equalRow(stateKey(None,'phase'),'end'), True: True, # Sylvania does not do anything in the null phase after Freedonia responds to rejection False: False})) # Sylvania must act in its other phases if model == 'slantchev': # Attacking legal only under engagement phase for action in filterActions({'verb': 'attack'},free.actions | sylv.actions): agent = world.agents[action['subject']] agent.setLegal(action,makeTree({'if': equalRow(stateKey(None,'phase'),'engagement'), True: True, # Attacking legal only in engagement False: False})) # Attacking legal every other phase # Goals for Freedonia goalFTroops = maximizeFeature(stateKey(free.name,'troops')) free.setReward(goalFTroops,1.) goalFTerritory = maximizeFeature(stateKey(free.name,'territory')) free.setReward(goalFTerritory,1.) # Goals for Sylvania goalSTroops = maximizeFeature(stateKey(sylv.name,'troops')) sylv.setReward(goalSTroops,1.) goalSTerritory = minimizeFeature(stateKey(free.name,'territory')) sylv.setReward(goalSTerritory,1.) # Possible goals applicable to both goalAgreement = maximizeFeature(stateKey(None,'treaty')) # Silly goal, provided as an example of an achievement goal goalAchieve = achieveFeatureValue(stateKey(None,'phase'),'respond') # Horizons if model == 'powell': free.setAttribute('horizon',4) sylv.setAttribute('horizon',4) elif model == 'slantchev': free.setAttribute('horizon',6) sylv.setAttribute('horizon',6) # Discount factors free.setAttribute('discount',-1) sylv.setAttribute('discount',-1) # Levels of belief free.setRecursiveLevel(2) sylv.setRecursiveLevel(2) # Dynamics of battle freeTroops = stateKey(free.name,'troops') freeTerr = stateKey(free.name,'territory') sylvTroops = stateKey(sylv.name,'troops') # Effect of fighting for action in filterActions({'verb': 'attack'},free.actions | sylv.actions): # Effect on troops (cost of battle) tree = makeTree(addFeatureMatrix(freeTroops,stateKey(free.name,'cost'),-1.)) world.setDynamics(freeTroops,action,tree,enforceMin=not web) tree = makeTree(addFeatureMatrix(sylvTroops,stateKey(sylv.name,'cost'),-1.)) world.setDynamics(sylvTroops,action,tree,enforceMin=not web) if model == 'powell': # Effect on territory (probability of collapse) tree = makeTree({'distribution': [ ({'distribution': [(setToConstantMatrix(freeTerr,100),1.-fCollapse), # Sylvania collapses, Freedonia does not (noChangeMatrix(freeTerr), fCollapse)]}, # Both collapse sCollapse), ({'distribution': [(setToConstantMatrix(freeTerr,0),fCollapse), # Freedonia collapses, Sylvania does not (noChangeMatrix(freeTerr), 1.-fCollapse)]}, # Neither collapses 1.-sCollapse)]}) world.setDynamics(freeTerr,action,tree) elif model == 'slantchev': # Effect on position pos = stateKey(free.name,'position') tree = makeTree({'distribution': [(incrementMatrix(pos,1),1.-fCollapse), # Freedonia wins battle (incrementMatrix(pos,-1),fCollapse)]}) # Freedonia loses battle world.setDynamics(pos,action,tree) # Effect on territory tree = makeTree({'if': thresholdRow(pos,posHi-.5), True: setToConstantMatrix(freeTerr,100), # Freedonia won False: {'if': thresholdRow(pos,posLo+.5), True: noChangeMatrix(freeTerr), False: setToConstantMatrix(freeTerr,0)}}) # Freedonia lost world.setDynamics(freeTerr,action,tree) # Dynamics of offers for index in range(2): atom = Action({'subject': world.agents.keys()[index],'verb': 'offer', 'object': world.agents.keys()[1-index]}) if atom['subject'] == free.name or model != 'powell': offer = stateKey(atom['object'],'offered') amount = actionKey('amount') tree = makeTree({'if': trueRow(stateKey(None,'treaty')), True: noChangeMatrix(offer), False: setToConstantMatrix(offer,amount)}) world.setDynamics(offer,atom,tree,enforceMax=not web) # Dynamics of treaties for action in filterActions({'verb': 'accept offer'},free.actions | sylv.actions): # Accepting an offer means that there is now a treaty key = stateKey(None,'treaty') tree = makeTree(setTrueMatrix(key)) world.setDynamics(key,action,tree) # Accepting offer sets territory offer = stateKey(action['subject'],'offered') territory = stateKey(free.name,'territory') if action['subject'] == free.name: # Freedonia accepts sets territory to last offer tree = makeTree(setToFeatureMatrix(territory,offer)) world.setDynamics(freeTerr,action,tree) else: # Sylvania accepts sets territory to 1-last offer tree = makeTree(setToFeatureMatrix(territory,offer,pct=-1.,shift=100.)) world.setDynamics(freeTerr,action,tree) # Dynamics of phase phase = stateKey(None,'phase') roundKey = stateKey(None,'round') # OFFER -> RESPOND for index in range(2): action = Action({'subject': world.agents.keys()[index],'verb': 'offer', 'object': world.agents.keys()[1-index]}) if action['subject'] == free.name or model != 'powell': tree = makeTree(setToConstantMatrix(phase,'respond')) world.setDynamics(phase,action,tree) # RESPOND -> REJECTION or ENGAGEMENT for action in filterActions({'verb': 'reject offer'},free.actions | sylv.actions): if model == 'powell': tree = makeTree(setToConstantMatrix(phase,'rejection')) elif model == 'slantchev': tree = makeTree(setToConstantMatrix(phase,'engagement')) world.setDynamics(phase,action,tree) # accepting -> OFFER for action in filterActions({'verb': 'accept offer'},free.actions | sylv.actions): tree = makeTree(setToConstantMatrix(phase,'offer')) world.setDynamics(phase,action,tree) # attacking -> OFFER for action in filterActions({'verb': 'attack'},free.actions | sylv.actions): tree = makeTree(setToConstantMatrix(phase,'offer')) world.setDynamics(phase,action,tree) if action['subject'] == sylv.name or model == 'slantchev': tree = makeTree(incrementMatrix(roundKey,1)) world.setDynamics(roundKey,action,tree) if model == 'powell': # REJECTION -> END for atom in [freeNOP,freeBattle]: tree = makeTree(setToConstantMatrix(phase,'end')) world.setDynamics(phase,atom,tree) # END -> OFFER atom = Action({'subject': sylv.name,'verb': 'continue'}) tree = makeTree(setToConstantMatrix(phase,'offer')) world.setDynamics(phase,atom,tree) tree = makeTree(incrementMatrix(roundKey,1)) world.setDynamics(roundKey,atom,tree) if not web: # Relationship dynamics: attacking is bad for trust atom = Action({'subject': sylv.name,'verb': 'attack','object': free.name}) key = binaryKey(free.name,sylv.name,'trusts') tree = makeTree(approachMatrix(key,0.1,-1.)) world.setDynamics(key,atom,tree) # Handcrafted policy for Freedonia # free.setPolicy(makeTree({'if': equalRow('phase','respond'), # # Accept an offer greater than 50 # True: {'if': thresholdRow(stateKey(free.name,'offered'),50), # True: Action({'subject': free.name,'verb': 'accept offer','object': sylv.name}), # False: Action({'subject': free.name,'verb': 'reject offer','object': sylv.name})}, # False: {'if': equalRow('phase','engagement'), # # Attack during engagement phase # True: Action({'subject': free.name,'verb': 'attack','object': sylv.name}), # # Agent decides how what to do otherwise # False: False}})) # Mental models of enemy # Example of creating a model with incorrect reward all at once (a version of Freedonia who cares about reaching agreement as well) # sylv.addModel('false',R={goalSTroops: 10.,goalSTerritory: 1.,goalAgreement: 1.}, # rationality=1.,selection='distribution',parent=True) # Example of creating a model with incorrect beliefs sylv.addModel('false',rationality=10.,selection='distribution',parent=True) key = stateKey(free.name,'position') # Sylvania believes position to be fixed at 3 sylv.setBelief(key,3,'false') # Freedonia is truly unsure about position (50% chance of being 7, 50% of being 3) world.setModel(free.name,True) free.setBelief(key,Distribution({7: 0.5,3: 0.5}),True) # Observations about military position tree = makeTree({'if': thresholdRow(key,1), True: {'if': thresholdRow(key,9), True: {'distribution': [(KeyedVector({key: 1}),0.9), (KeyedVector({key: 1,CONSTANT: -1}),0.1)]}, False: {'distribution': [(KeyedVector({key: 1}),0.8), (KeyedVector({key: 1,CONSTANT: -1}),0.1), (KeyedVector({key: 1,CONSTANT: 1}),0.1)]}}, False: {'distribution': [(KeyedVector({key: 1}),0.9), (KeyedVector({key: 1,CONSTANT: 1}),0.1)]}}) free.defineObservation(key,tree) # Example of setting model parameters separately sylv.addModel('true',parent=True) sylv.setAttribute('rationality',10.,'true') # Override real agent's rationality with this value sylv.setAttribute('selection','distribution','true') world.setMentalModel(free.name,sylv.name,{'false': 0.9,'true': 0.1}) # Goal of fooling Sylvania goalDeception = achieveFeatureValue(modelKey(sylv.name),sylv.model2index('false')) return world
# Create scenario world = World() totals = {'exiter':3,'follower':4, 'avoider':3} # # there are a mix of agent types that have different reward preferences for heading towards door, # following someone who is closest or avoiding the fire rewardWeights = {'exiter':{'fire':.4,'door':.5,'follow':.1},'follower':{'fire':.2,'door':.2,'follow':.6},'avoider':{'fire':.6,'door':.3,'follow':.1}} # the fire and door are modeled as agents with no actions - they only have a fixed location me = Agent('door') world.addAgent(me) world.defineState(me.name,'x',float) world.setState(me.name,'x',5) world.defineState(me.name,'y',float) world.setState(me.name,'y',5) me.setHorizon(0) me = Agent('fire') world.addAgent(me) world.defineState(me.name,'x',float) world.setState(me.name,'x',1) world.defineState(me.name,'y',float) world.setState(me.name,'y',1) me.setHorizon(0) # Player state, actions and parameters common to both players embodiedAgts = [] for base in ['exiter','follower','avoider']:
# David state david = Agent('David') world.addAgent(david) world.defineState(david.name,'applesOwned',int,lo=0,hi=totals['apple']) david.setState('applesOwned',0) world.defineState(david.name,'applesOffered',int,lo=0,hi=totals['apple']) david.setState('applesOffered',0) world.defineState(david.name,'pearsOwned',int,lo=0,hi=totals['pear']) david.setState('pearsOwned',0) world.defineState(david.name,'pearsOffered',int,lo=0,hi=totals['pear']) david.setState('pearsOffered',0) # World state world.defineState(None,'agreement',bool) world.setState(None,'agreement',False) world.defineState(None,'applesOffer',bool) world.setState(None,'applesOffer',False) world.defineState(None,'pearsOffer',bool) world.setState(None,'pearsOffer',False) world.termination.append(makeTree({'if': trueRow(stateKey(None,'agreement')), True: True, False: False})) # Turn order: Uncomment the following if you want agents to act in parallel # world.setOrder([[stacy.name,david.name]]) # Turn order: Uncomment the following if you want agents to act sequentially world.setOrder([stacy.name,david.name]) # Stacy actions
# Parameters me.setHorizon(6) # me.setParameter('discount',0.9) #me.setParameter('discount',0.9) # Levels of belief david.setRecursiveLevel(3) stacy.setRecursiveLevel(3) # Turn order: Uncomment the following if you want agents to act in parallel #world.setOrder([{agts[0].name,agts[1].name}]) # Turn order: Uncomment the following if you want agents to act sequentially world.setOrder([agts[0].name, agts[1].name]) # World state world.defineState(None, 'agreement', bool) world.setState(None, 'agreement', False) world.defineState(None, 'scotchOffer', bool) world.setState(None, 'scotchOffer', False) world.defineState(None, 'tequilaOffer', bool) world.setState(None, 'tequilaOffer', False) world.defineState(None, 'round', int, description='The current round of the negotiation') world.setState(None, 'round', 0) world.addTermination( makeTree({ 'if': trueRow(stateKey(None, 'agreement')), True: True, False: False
# Parameters me.setHorizon(4) # me.setParameter('discount',0.9) me.setParameter('discount',0.9) # Levels of belief david.setRecursiveLevel(3) stacy.setRecursiveLevel(3) # Turn order: Uncomment the following if you want agents to act in parallel #world.setOrder([{agts[0].name,agts[1].name}]) # Turn order: Uncomment the following if you want agents to act sequentially world.setOrder([agts[0].name,agts[1].name]) # World state world.defineState(None,'agreement',bool) world.setState(None,'agreement',False) world.defineState(None,'scotchOffer',bool) world.setState(None,'scotchOffer',False) world.defineState(None,'tequilaOffer',bool) world.setState(None,'tequilaOffer',False) world.termination.append(makeTree({'if': trueRow(stateKey(None,'agreement')), True: True, False: False})) ####################### # A more flexible way to specify the payoffs would be better # for example we would want to capture that a person might want # one scotch but no more and as many tequila as they could get
class Ultimatum: def __init__(self): self.world = World() stacy = Agent('Stacy') david = Agent('David') agts = [stacy, david] totalAmt = 4 # Player state, actions and parameters common to both players for i in range(2): me = agts[i] other = agts[1 - i] self.world.addAgent(me) self.world.defineState(me.name, 'offered', int, lo=0, hi=totalAmt) self.world.defineState(me.name, 'money', int, lo=0, hi=totalAmt) me.setState('offered', 0) me.setState('money', 0) if (me.name == 'Stacy'): for amt in range(totalAmt + 1): me.addAction({ 'verb': 'offer', 'object': other.name, 'amount': amt }) else: mePass = me.addAction({'verb': 'accept', 'object': other.name}) mePass = me.addAction({'verb': 'reject', 'object': other.name}) # Parameters me.setHorizon(2) me.setParameter('discount', 0.9) # me.setParameter('discount',1.0) # Levels of belief david.setRecursiveLevel(3) stacy.setRecursiveLevel(3) self.world.setOrder(['Stacy', 'David']) # World state self.world.defineState(None, 'gameOver', bool, description='The current round') self.world.setState(None, 'gameOver', False) self.world.addTermination( makeTree({ 'if': trueRow(stateKey(None, 'gameOver')), True: True, False: False })) # offer dynamics atom = Action({'subject': 'Stacy', 'verb': 'offer', 'object': 'David'}) parties = [atom['subject'], atom['object']] for j in range(2): offer = stateKey(parties[j], 'offered') amount = actionKey('amount') if j == 1 else '%d-%s' % ( totalAmt, actionKey('amount')) tree = makeTree(setToConstantMatrix(offer, amount)) self.world.setDynamics(parties[j], 'offered', atom, tree) # accept dynamics atom = Action({ 'subject': 'David', 'verb': 'accept', 'object': 'Stacy' }) parties = [atom['subject'], atom['object']] for j in range(2): offer = stateKey(parties[j], 'offered') money = stateKey(parties[j], 'money') tree = makeTree(setToFeatureMatrix(money, offer)) self.world.setDynamics(parties[j], 'money', atom, tree) tree = makeTree(setTrueMatrix(stateKey(None, 'gameOver'))) self.world.setDynamics(None, 'gameOver', atom, tree) # reject dynamics atom = Action({ 'subject': 'David', 'verb': 'reject', 'object': 'Stacy' }) tree = makeTree(setTrueMatrix(stateKey(None, 'gameOver'))) self.world.setDynamics(None, 'gameOver', atom, tree) # really need to ask david about these levels - if adding modesl with levels, can # the true model point to these but have a different level for agent in self.world.agents.values(): agent.addModel('Christian', R={}, level=2, rationality=25., selection='distribution') agent.addModel('Capitalist', R={}, level=2, rationality=25., selection='distribution') # agent.addModel('Christian',R={},level=2,rationality=10.,selection='distribution') # agent.addModel('Capitalist',R={},level=2,rationality=10.,selection='distribution') # agent.addModel('Christian',R={},level=2,rationality=10.,selection='distribution') # agent.addModel('Capitalist',R={},level=2,rationality=10.,selection='random') def modeltest(self, trueModels, davidBeliefAboutStacy, stacyBeliefAboutDavid, strongerBelief): agts = self.world.agents.values() for i in range(2): me = agts[i] other = agts[1 - i] for model in me.models.keys(): if model is True: name = trueModels[me.name] else: name = model if name == 'Capitalist': me.setReward(maximizeFeature(stateKey(me.name, 'money')), 1.0, model) elif name == 'Christian': me.setReward(maximizeFeature(stateKey(me.name, 'money')), 1.0, model) me.setReward( maximizeFeature(stateKey(other.name, 'money')), 1.0, model) weakBelief = 1.0 - strongerBelief print weakBelief belief = {'Christian': weakBelief, 'Capitalist': weakBelief} belief[davidBeliefAboutStacy] = strongerBelief self.world.setMentalModel('David', 'Stacy', belief) belief = {'Christian': weakBelief, 'Capitalist': weakBelief} belief[stacyBeliefAboutDavid] = strongerBelief self.world.setMentalModel('Stacy', 'David', belief) def runit(self, Msg): print Msg for t in range(2): self.world.explain(self.world.step(), level=2) # print self.world.step() self.world.state.select() # self.world.printState() if self.world.terminated(): break
class Negotiate: def __init__(self,turnOrder): self.maxRounds=8 self.world = World() totals = {'apple':1,'pear':2} batna_prePref = totals['apple'] + totals['pear'] stacy = Agent('Stacy') david = Agent('David') agts = [stacy, david] # Player state, actions and parameters common to both players for i in range(2): me = agts[i] other = agts[1-i] self.world.addAgent(me) # State self.world.defineState(me.name,'appleOwned',int,lo=0,hi=totals['apple']) me.setState('appleOwned',0) self.world.defineState(me.name,'appleOffered',int,lo=0,hi=totals['apple']) me.setState('appleOffered',0) self.world.defineState(me.name,'pearOwned',int,lo=0,hi=totals['pear']) me.setState('pearOwned',0) self.world.defineState(me.name,'pearOffered',int,lo=0,hi=totals['pear']) me.setState('pearOffered',0) self.world.defineState(me.name,'Batna',int,lo=0,hi=10) me.setState('Batna', batna_prePref) self.world.defineState(me.name,'BatnaOwned',int,lo=0,hi=10) me.setState('BatnaOwned',0) self.world.defineState(me.name,'agree',bool) me.setState('agree',False) # Actions me.addAction({'verb': 'do nothing'}) for amt in range(totals['apple'] + 1): tmp = me.addAction({'verb': 'offerApple','object': other.name,'amount': amt}) me.setLegal(tmp,makeTree({'if': trueRow(stateKey(None, 'agreement')), False: {'if': trueRow(stateKey(None, 'rejectedNegotiation')), True: False, False: True}, True: False})) for amt in range(totals['pear'] + 1): tmp = me.addAction({'verb': 'offerPear','object': other.name,'amount': amt}) me.setLegal(tmp,makeTree({'if': trueRow(stateKey(None, 'agreement')), False: {'if': trueRow(stateKey(None, 'rejectedNegotiation')), True: False, False: True}, True: False})) meReject = me.addAction({'verb': 'rejectNegotiation','object': other.name}) me.setLegal(meReject,makeTree({'if': trueRow(stateKey(None, 'agreement')), False: {'if': trueRow(stateKey(None, 'rejectedNegotiation')), True: False, False: True}, True: False})) meAccept = me.addAction({'verb': 'accept offer','object': other.name}) me.setLegal(meAccept,makeTree({'if': trueRow(stateKey(None, 'appleOffer')), True: {'if': trueRow(stateKey(None, 'pearOffer')), True: {'if': trueRow(stateKey(None, 'agreement')), False: {'if': trueRow(stateKey(None, 'rejectedNegotiation')), True: False, False: True}, True: False}, False: False}, False: False})) # Parameters me.setHorizon(6) me.setParameter('discount',0.9) # Levels of belief david.setRecursiveLevel(3) stacy.setRecursiveLevel(3) # Turn order: Uncomment the following if you want agents to act in parallel # world.setOrder([{agts[0].name,agts[1].name}]) # Turn order: Uncomment the following if you want agents to act sequentially self.world.setOrder(turnOrder) # World state self.world.defineState(None,'agreement',bool) self.world.setState(None,'agreement',False) self.world.defineState(None,'appleOffer',bool) self.world.setState(None,'appleOffer',False) self.world.defineState(None,'pearOffer',bool) self.world.setState(None,'pearOffer',False) self.world.defineState(None,'round',int,description='The current round of the negotiation') self.world.setState(None,'round',0) self.world.defineState(None,'rejectedNegotiation',bool, description='Have one of the players walked out?') self.world.setState(None, 'rejectedNegotiation', False) # dont terminate so agent sees benefit of early agreement # world.addTermination(makeTree({'if': trueRow(stateKey(None,'agreement')), # True: True, # False: False})) # world.addTermination(makeTree({'if': trueRow(stateKey(None,'rejectedNegotiation')), # True: True, # False: False})) self.world.addTermination(makeTree({'if': thresholdRow(stateKey(None,'round'),self.maxRounds), True: True, False: False})) # Dynamics of offers agents = [david.name,stacy.name] for i in range(2): for fruit in ['apple','pear']: atom = Action({'subject': agents[i],'verb': 'offer%s' % (fruit.capitalize()), 'object': agents[1-i]}) parties = [atom['subject'], atom['object']] for j in range(2): # Set offer amount offer = stateKey(parties[j],'%sOffered' % (fruit)) amount = actionKey('amount') if j == 1 else '%d-%s' % (totals[fruit],actionKey('amount')) tree = makeTree(setToConstantMatrix(offer,amount)) self.world.setDynamics(parties[j],'%sOffered' % (fruit),atom,tree) # reset agree flags whenever an offer is made agreeFlag = stateKey(parties[j],'agree') tree = makeTree(setFalseMatrix(agreeFlag)) self.world.setDynamics(parties[j],'agree',atom,tree) # Offers set offer flag in world state tree = makeTree(setTrueMatrix(stateKey(None,'%sOffer' % (fruit)))) self.world.setDynamics(None,'%sOffer' % (fruit) ,atom,tree) # agents = [david.name,stacy.name] # Dynamics of agreements for i in range(2): atom = Action({'subject': agents[i],'verb': 'accept offer', 'object': agents[1-i]}) # accept offer sets accept tree = makeTree(setTrueMatrix(stateKey(atom['subject'],'agree'))) self.world.setDynamics(atom['subject'],'agree',atom,tree) # accept offer sets agreement if object has accepted tree = makeTree({'if': trueRow(stateKey(atom['object'],'agree')), True: setTrueMatrix(stateKey(None,'agreement')), False: noChangeMatrix(stateKey(None,'agreement'))}) self.world.setDynamics(None,'agreement',atom,tree) # Accepting offer sets ownership parties = [atom['subject'], atom['object']] for fruit in ['apple','pear']: # atom = Action({'subject': agents[i],'verb': 'accept offer', 'object': agents[1-i]}) for j in range(2): offer = stateKey(parties[j],'%sOffered' % (fruit)) owned = stateKey(parties[j],'%sOwned' % (fruit)) tree = makeTree({'if': trueRow(stateKey(atom['object'],'agree')), False: noChangeMatrix(owned), True: setToFeatureMatrix(owned,offer)}) self.world.setDynamics(parties[j],'%sOwned' % (fruit),atom,tree) # rejecting give us batna and ends negotiation atom = Action({'subject': agents[i],'verb': 'rejectNegotiation', 'object': agents[1-i]}) tree = makeTree(setToFeatureMatrix(stateKey(atom['subject'],'BatnaOwned') ,stateKey(atom['subject'], 'Batna'))) self.world.setDynamics(atom['subject'],'BatnaOwned' ,atom,tree) tree = makeTree(setToFeatureMatrix(stateKey(atom['object'],'BatnaOwned') ,stateKey(atom['object'], 'Batna'))) self.world.setDynamics(atom['object'],'BatnaOwned' ,atom,tree) tree = makeTree(setTrueMatrix(stateKey(None,'rejectedNegotiation'))) self.world.setDynamics(None,'rejectedNegotiation' ,atom,tree) for action in stacy.actions | david.actions: tree = makeTree(incrementMatrix(stateKey(None,'round'),1)) self.world.setDynamics(None,'round',action,tree) for agent in self.world.agents.values(): agent.addModel('pearLover',R={},level=2,rationality=0.01) agent.addModel('appleLover',R={},level=2,rationality=0.01) def modeltest(self,trueModels,davidBeliefAboutStacy,stacyBeliefAboutDavid,strongerBelief): for agent in self.world.agents.values(): for model in agent.models.keys(): if model is True: name = trueModels[agent.name] else: name = model if name == 'appleLover': agent.setReward(maximizeFeature(stateKey(agent.name,'appleOwned')),4.0,model) agent.setReward(maximizeFeature(stateKey(agent.name,'pearOwned')),1.0,model) agent.setReward(maximizeFeature(stateKey(agent.name,'BatnaOwned')),0.1,model) elif name == 'pearLover': agent.setReward(maximizeFeature(stateKey(agent.name,'appleOwned')),1.0,model) agent.setReward(maximizeFeature(stateKey(agent.name,'pearOwned')),4.0,model) agent.setReward(maximizeFeature(stateKey(agent.name,'BatnaOwned')),0.1,model) weakBelief = 1.0 - strongerBelief belief = {'pearLover': weakBelief,'appleLover': weakBelief} belief[davidBeliefAboutStacy] = strongerBelief self.world.setMentalModel('David','Stacy',belief) belief = {'pearLover': weakBelief,'appleLover': weakBelief} belief[stacyBeliefAboutDavid] = strongerBelief self.world.setMentalModel('Stacy','David',belief) def runit(self,Msg): print Msg for t in range(self.maxRounds + 1): self.world.explain(self.world.step(),level=1) # print self.world.step() self.world.state.select() # self.world.printState() if self.world.terminated(): break
world.defineState(david.name, 'applesOwned', int, lo=0, hi=totals['apple']) david.setState('applesOwned', 0) world.defineState(david.name, 'applesOffered', int, lo=0, hi=totals['apple']) david.setState('applesOffered', 0) world.defineState(david.name, 'pearsOwned', int, lo=0, hi=totals['pear']) david.setState('pearsOwned', 0) world.defineState(david.name, 'pearsOffered', int, lo=0, hi=totals['pear']) david.setState('pearsOffered', 0) # World state world.defineState(None, 'agreement', bool) world.setState(None, 'agreement', False) world.defineState(None, 'applesOffer', bool) world.setState(None, 'applesOffer', False) world.defineState(None, 'pearsOffer', bool) world.setState(None, 'pearsOffer', False) world.termination.append( makeTree({ 'if': trueRow(stateKey(None, 'agreement')), True: True, False: False })) # Turn order: Uncomment the following if you want agents to act in parallel # world.setOrder([[stacy.name,david.name]]) # Turn order: Uncomment the following if you want agents to act sequentially
class Ultimatum: def __init__(self): self.world = World() stacy = Agent('Stacy') david = Agent('David') agts = [stacy, david] totalAmt = 4 # Player state, actions and parameters common to both players for i in range(2): me = agts[i] other = agts[1-i] self.world.addAgent(me) self.world.defineState(me.name,'offered',int,lo=0,hi=totalAmt) self.world.defineState(me.name,'money',int,lo=0,hi=totalAmt) me.setState('offered',0) me.setState('money',0) if (me.name == 'Stacy'): for amt in range(totalAmt + 1): me.addAction({'verb': 'offer','object': other.name,'amount': amt}) else: mePass = me.addAction({'verb': 'accept','object': other.name}) mePass = me.addAction({'verb': 'reject','object': other.name}) # Parameters me.setHorizon(2) me.setParameter('discount',0.9) # me.setParameter('discount',1.0) # Levels of belief david.setRecursiveLevel(3) stacy.setRecursiveLevel(3) self.world.setOrder(['Stacy','David']) # World state self.world.defineState(None,'gameOver',bool,description='The current round') self.world.setState(None,'gameOver',False) self.world.addTermination(makeTree({'if': trueRow(stateKey(None,'gameOver')), True: True, False: False})) # offer dynamics atom = Action({'subject': 'Stacy','verb': 'offer', 'object': 'David'}) parties = [atom['subject'], atom['object']] for j in range(2): offer = stateKey(parties[j],'offered') amount = actionKey('amount') if j == 1 else '%d-%s' % (totalAmt,actionKey('amount')) tree = makeTree(setToConstantMatrix(offer,amount)) self.world.setDynamics(parties[j],'offered',atom,tree) # accept dynamics atom = Action({'subject': 'David','verb': 'accept', 'object': 'Stacy'}) parties = [atom['subject'], atom['object']] for j in range(2): offer = stateKey(parties[j],'offered') money = stateKey(parties[j],'money') tree = makeTree(setToFeatureMatrix(money,offer)) self.world.setDynamics(parties[j],'money',atom,tree) tree=makeTree(setTrueMatrix(stateKey(None,'gameOver'))) self.world.setDynamics(None,'gameOver',atom,tree) # reject dynamics atom = Action({'subject': 'David','verb': 'reject', 'object': 'Stacy'}) tree=makeTree(setTrueMatrix(stateKey(None,'gameOver'))) self.world.setDynamics(None,'gameOver',atom,tree) # really need to ask david about these levels - if adding modesl with levels, can # the true model point to these but have a different level for agent in self.world.agents.values(): agent.addModel('Christian',R={},level=2,rationality=25.,selection='distribution') agent.addModel('Capitalist',R={},level=2,rationality=25.,selection='distribution') # agent.addModel('Christian',R={},level=2,rationality=10.,selection='distribution') # agent.addModel('Capitalist',R={},level=2,rationality=10.,selection='distribution') # agent.addModel('Christian',R={},level=2,rationality=10.,selection='distribution') # agent.addModel('Capitalist',R={},level=2,rationality=10.,selection='random') def modeltest(self,trueModels,davidBeliefAboutStacy,stacyBeliefAboutDavid,strongerBelief): agts = self.world.agents.values() for i in range(2): me = agts[i] other = agts[1-i] for model in me.models.keys(): if model is True: name = trueModels[me.name] else: name = model if name == 'Capitalist': me.setReward(maximizeFeature(stateKey(me.name,'money')),1.0,model) elif name == 'Christian': me.setReward(maximizeFeature(stateKey(me.name,'money')),1.0,model) me.setReward(maximizeFeature(stateKey(other.name,'money')),1.0,model) weakBelief = 1.0 - strongerBelief print weakBelief belief = {'Christian': weakBelief,'Capitalist': weakBelief} belief[davidBeliefAboutStacy] = strongerBelief self.world.setMentalModel('David','Stacy',belief) belief = {'Christian': weakBelief,'Capitalist': weakBelief} belief[stacyBeliefAboutDavid] = strongerBelief self.world.setMentalModel('Stacy','David',belief) def runit(self,Msg): print Msg for t in range(2): self.world.explain(self.world.step(),level=2) # print self.world.step() self.world.state.select() # self.world.printState() if self.world.terminated(): break
class Negotiate: def __init__(self, turnOrder): self.maxRounds = 8 self.world = World() totals = {'apple': 1, 'pear': 2} batna_prePref = totals['apple'] + totals['pear'] stacy = Agent('Stacy') david = Agent('David') agts = [stacy, david] # Player state, actions and parameters common to both players for i in range(2): me = agts[i] other = agts[1 - i] self.world.addAgent(me) # State self.world.defineState(me.name, 'appleOwned', int, lo=0, hi=totals['apple']) me.setState('appleOwned', 0) self.world.defineState(me.name, 'appleOffered', int, lo=0, hi=totals['apple']) me.setState('appleOffered', 0) self.world.defineState(me.name, 'pearOwned', int, lo=0, hi=totals['pear']) me.setState('pearOwned', 0) self.world.defineState(me.name, 'pearOffered', int, lo=0, hi=totals['pear']) me.setState('pearOffered', 0) self.world.defineState(me.name, 'Batna', int, lo=0, hi=10) me.setState('Batna', batna_prePref) self.world.defineState(me.name, 'BatnaOwned', int, lo=0, hi=10) me.setState('BatnaOwned', 0) self.world.defineState(me.name, 'agree', bool) me.setState('agree', False) # Actions me.addAction({'verb': 'do nothing'}) for amt in range(totals['apple'] + 1): tmp = me.addAction({ 'verb': 'offerApple', 'object': other.name, 'amount': amt }) me.setLegal( tmp, makeTree({ 'if': trueRow(stateKey(None, 'agreement')), False: { 'if': trueRow(stateKey(None, 'rejectedNegotiation')), True: False, False: True }, True: False })) for amt in range(totals['pear'] + 1): tmp = me.addAction({ 'verb': 'offerPear', 'object': other.name, 'amount': amt }) me.setLegal( tmp, makeTree({ 'if': trueRow(stateKey(None, 'agreement')), False: { 'if': trueRow(stateKey(None, 'rejectedNegotiation')), True: False, False: True }, True: False })) meReject = me.addAction({ 'verb': 'rejectNegotiation', 'object': other.name }) me.setLegal( meReject, makeTree({ 'if': trueRow(stateKey(None, 'agreement')), False: { 'if': trueRow(stateKey(None, 'rejectedNegotiation')), True: False, False: True }, True: False })) meAccept = me.addAction({ 'verb': 'accept offer', 'object': other.name }) me.setLegal( meAccept, makeTree({ 'if': trueRow(stateKey(None, 'appleOffer')), True: { 'if': trueRow(stateKey(None, 'pearOffer')), True: { 'if': trueRow(stateKey(None, 'agreement')), False: { 'if': trueRow(stateKey(None, 'rejectedNegotiation')), True: False, False: True }, True: False }, False: False }, False: False })) # Parameters me.setHorizon(6) me.setParameter('discount', 0.9) # Levels of belief david.setRecursiveLevel(3) stacy.setRecursiveLevel(3) # Turn order: Uncomment the following if you want agents to act in parallel # world.setOrder([{agts[0].name,agts[1].name}]) # Turn order: Uncomment the following if you want agents to act sequentially self.world.setOrder(turnOrder) # World state self.world.defineState(None, 'agreement', bool) self.world.setState(None, 'agreement', False) self.world.defineState(None, 'appleOffer', bool) self.world.setState(None, 'appleOffer', False) self.world.defineState(None, 'pearOffer', bool) self.world.setState(None, 'pearOffer', False) self.world.defineState( None, 'round', int, description='The current round of the negotiation') self.world.setState(None, 'round', 0) self.world.defineState( None, 'rejectedNegotiation', bool, description='Have one of the players walked out?') self.world.setState(None, 'rejectedNegotiation', False) # dont terminate so agent sees benefit of early agreement # world.addTermination(makeTree({'if': trueRow(stateKey(None,'agreement')), # True: True, # False: False})) # world.addTermination(makeTree({'if': trueRow(stateKey(None,'rejectedNegotiation')), # True: True, # False: False})) self.world.addTermination( makeTree({ 'if': thresholdRow(stateKey(None, 'round'), self.maxRounds), True: True, False: False })) # Dynamics of offers agents = [david.name, stacy.name] for i in range(2): for fruit in ['apple', 'pear']: atom = Action({ 'subject': agents[i], 'verb': 'offer%s' % (fruit.capitalize()), 'object': agents[1 - i] }) parties = [atom['subject'], atom['object']] for j in range(2): # Set offer amount offer = stateKey(parties[j], '%sOffered' % (fruit)) amount = actionKey('amount') if j == 1 else '%d-%s' % ( totals[fruit], actionKey('amount')) tree = makeTree(setToConstantMatrix(offer, amount)) self.world.setDynamics(parties[j], '%sOffered' % (fruit), atom, tree) # reset agree flags whenever an offer is made agreeFlag = stateKey(parties[j], 'agree') tree = makeTree(setFalseMatrix(agreeFlag)) self.world.setDynamics(parties[j], 'agree', atom, tree) # Offers set offer flag in world state tree = makeTree( setTrueMatrix(stateKey(None, '%sOffer' % (fruit)))) self.world.setDynamics(None, '%sOffer' % (fruit), atom, tree) # agents = [david.name,stacy.name] # Dynamics of agreements for i in range(2): atom = Action({ 'subject': agents[i], 'verb': 'accept offer', 'object': agents[1 - i] }) # accept offer sets accept tree = makeTree(setTrueMatrix(stateKey(atom['subject'], 'agree'))) self.world.setDynamics(atom['subject'], 'agree', atom, tree) # accept offer sets agreement if object has accepted tree = makeTree({ 'if': trueRow(stateKey(atom['object'], 'agree')), True: setTrueMatrix(stateKey(None, 'agreement')), False: noChangeMatrix(stateKey(None, 'agreement')) }) self.world.setDynamics(None, 'agreement', atom, tree) # Accepting offer sets ownership parties = [atom['subject'], atom['object']] for fruit in ['apple', 'pear']: # atom = Action({'subject': agents[i],'verb': 'accept offer', 'object': agents[1-i]}) for j in range(2): offer = stateKey(parties[j], '%sOffered' % (fruit)) owned = stateKey(parties[j], '%sOwned' % (fruit)) tree = makeTree({ 'if': trueRow(stateKey(atom['object'], 'agree')), False: noChangeMatrix(owned), True: setToFeatureMatrix(owned, offer) }) self.world.setDynamics(parties[j], '%sOwned' % (fruit), atom, tree) # rejecting give us batna and ends negotiation atom = Action({ 'subject': agents[i], 'verb': 'rejectNegotiation', 'object': agents[1 - i] }) tree = makeTree( setToFeatureMatrix(stateKey(atom['subject'], 'BatnaOwned'), stateKey(atom['subject'], 'Batna'))) self.world.setDynamics(atom['subject'], 'BatnaOwned', atom, tree) tree = makeTree( setToFeatureMatrix(stateKey(atom['object'], 'BatnaOwned'), stateKey(atom['object'], 'Batna'))) self.world.setDynamics(atom['object'], 'BatnaOwned', atom, tree) tree = makeTree( setTrueMatrix(stateKey(None, 'rejectedNegotiation'))) self.world.setDynamics(None, 'rejectedNegotiation', atom, tree) for action in stacy.actions | david.actions: tree = makeTree(incrementMatrix(stateKey(None, 'round'), 1)) self.world.setDynamics(None, 'round', action, tree) for agent in self.world.agents.values(): agent.addModel('pearLover', R={}, level=2, rationality=0.01) agent.addModel('appleLover', R={}, level=2, rationality=0.01) def modeltest(self, trueModels, davidBeliefAboutStacy, stacyBeliefAboutDavid, strongerBelief): for agent in self.world.agents.values(): for model in agent.models.keys(): if model is True: name = trueModels[agent.name] else: name = model if name == 'appleLover': agent.setReward( maximizeFeature(stateKey(agent.name, 'appleOwned')), 4.0, model) agent.setReward( maximizeFeature(stateKey(agent.name, 'pearOwned')), 1.0, model) agent.setReward( maximizeFeature(stateKey(agent.name, 'BatnaOwned')), 0.1, model) elif name == 'pearLover': agent.setReward( maximizeFeature(stateKey(agent.name, 'appleOwned')), 1.0, model) agent.setReward( maximizeFeature(stateKey(agent.name, 'pearOwned')), 4.0, model) agent.setReward( maximizeFeature(stateKey(agent.name, 'BatnaOwned')), 0.1, model) weakBelief = 1.0 - strongerBelief belief = {'pearLover': weakBelief, 'appleLover': weakBelief} belief[davidBeliefAboutStacy] = strongerBelief self.world.setMentalModel('David', 'Stacy', belief) belief = {'pearLover': weakBelief, 'appleLover': weakBelief} belief[stacyBeliefAboutDavid] = strongerBelief self.world.setMentalModel('Stacy', 'David', belief) def runit(self, Msg): print Msg for t in range(self.maxRounds + 1): self.world.explain(self.world.step(), level=1) # print self.world.step() self.world.state.select() # self.world.printState() if self.world.terminated(): break
class Centipede: def __init__(self,turnOrder,maxRounds,payoff): self.maxRounds=maxRounds self.payoff = payoff print self.payoff self.world = World() stacy = Agent('Stacy') david = Agent('David') agts = [stacy, david] # Player state, actions and parameters common to both players for i in range(2): me = agts[i] other = agts[1-i] self.world.addAgent(me) # State self.world.defineState(me.name,'money',int) me.setState('money',0) mePass = me.addAction({'verb': 'pass','object': other.name}) meTake = me.addAction({'verb': 'take','object': other.name}) # Parameters me.setHorizon(6) me.setAttribute('discount',1.) # me.setAttribute('discount',0.9) # Levels of belief david.setRecursiveLevel(3) stacy.setRecursiveLevel(3) self.world.setOrder(turnOrder) # World state self.world.defineState(None,'round',int,description='The current round') self.world.setState(None,'round',0) self.world.defineState(None,'gameOver',bool,description='whether game is over') self.world.setState(None,'gameOver',False) self.world.addTermination(makeTree({'if': thresholdRow(stateKey(None,'round'),self.maxRounds), True: True, False: {'if': trueRow(stateKey(None,'gameOver')), True: True, False: False}})) # Dynamics for action in stacy.actions | david.actions: tree = makeTree(incrementMatrix(stateKey(None,'round'),1)) self.world.setDynamics(stateKey(None,'round'),action,tree) if (action['verb'] == 'take'): tree = makeTree(setTrueMatrix(stateKey(None,'gameOver'))) self.world.setDynamics(stateKey(None,'gameOver'),action,tree) agts = ['Stacy','David'] for i in range(2): key = stateKey(agts[i],'money') tree = makeTree(self.buildPayoff(0, key, self.payoff[agts[i]])) self.world.setDynamics(stateKey(agts[i],'money'),action,tree) elif action['verb'] == 'pass': agts = ['Stacy','David'] for i in range(2): key = stateKey(agts[i],'money') tree = makeTree({'if': equalRow(stateKey(None,'round'),self.maxRounds-1), True: setToConstantMatrix(key,self.payoff[agts[i]][self.maxRounds]), False: noChangeMatrix(key)}) self.world.setDynamics(stateKey(agts[i],'money'),action,tree) # really need to ask david about these levels - if adding modesl with levels, can # the true model point to these but have a different level for agent in self.world.agents.values(): agent.addModel('Christian',R={},level=2,rationality=10.,selection='distribution') agent.addModel('Capitalist',R={},level=2,rationality=10.,selection='distribution') # agent.addModel('Christian',R={},level=2,rationality=0.01) # agent.addModel('Capitalist',R={},level=2,rationality=0.01) def buildPayoff(self,rnd,key,payoff): if (rnd == self.maxRounds - 1): return setToConstantMatrix(key,payoff[rnd]) else: return {'if': equalRow(stateKey(None,'round'),rnd), True: setToConstantMatrix(key,payoff[rnd]), False: self.buildPayoff(rnd+1,key,payoff)} def modeltest(self,trueModels,davidBeliefAboutStacy,stacyBeliefAboutDavid,strongerBelief): agts = self.world.agents.values() for i in range(2): me = agts[i] other = agts[1-i] for model in me.models.keys(): if model is True: name = trueModels[me.name] else: name = model if name == 'Capitalist': me.setReward(maximizeFeature(stateKey(me.name,'money')),1.0,model) elif name == 'Christian': me.setReward(maximizeFeature(stateKey(me.name,'money')),1.0,model) me.setReward(maximizeFeature(stateKey(other.name,'money')),1.0,model) weakBelief = 1.0 - strongerBelief belief = {'Christian': weakBelief,'Capitalist': weakBelief} belief[davidBeliefAboutStacy] = strongerBelief self.world.setMentalModel('David','Stacy',belief) belief = {'Christian': weakBelief,'Capitalist': weakBelief} belief[stacyBeliefAboutDavid] = strongerBelief self.world.setMentalModel('Stacy','David',belief) def runit(self,Msg): print Msg for t in range(self.maxRounds + 1): self.world.explain(self.world.step(),level=2) # self.world.explain(self.world.step(),level=1) # print self.world.step() #self.world.state.select() # self.world.printState() if self.world.terminated(): break