October 2017 archive

Book review: The Art of Strategy by Avinash K. Dixit and Barry J. Nalebuff

art_of_strategyNext up, some work related reading. The Art of Strategy: A Game Theorist’s Guide to Success in Business and Life by Avinash K. Dixit and Barry J. Nalebuff.

The Art of Strategy is about game theory, a branch of economics / mathematics which considers such things as the “ultimate game” where one player choses how to split $100 (i.e. keeping $60 and giving away $40) and a second player decides to accept or reject the split, in the latter case neither of them gets any money. In the former case they get the offered split.

In the “prisoners dilemma” two prisoners are each offered the opportunity to give evidence against the other. If one of them does this, and the other doesn’t, then they will be set free, whilst their fellow prisoner services a sentence. If both betray the other then they will both serve a longer sentence than if they had both kept quiet.

These examples represent the simplest two main types of game, the ultimate game is an example of a sequential game (where one player makes a decision followed by the other) whilst the prisoners dilemma is an example of a simultaneous game (where players make their decisions simultaneously). In real life, chess is an example of a sequential game and a sealed bid auction is a simultaneous game. Games are rarely played as a single instance, simultaneous games may be repeated (“the best out of 3”), and sequentially games may involve many moves. This repetition enables the development of strategies such as “tit for tat” and punishment. 

The ultimate game and the prisoners dilemma provide a test bed for game theory, normally illustrating that real humans don’t act as the rational agents that economics intended! For example, in the ultimate game players really should accept any non-zero offer since the alternative is getting nothing, in practice players will reject offers even as high as $10 or $20 as unjust. 

Sequential games are modelled using “game trees”, which are like “decision trees”. Simultaneously games are modelled with payoff tables. The complexity of real sequential games, such as chess, means we cannot inspect all possible paths in the game tree, even with high power computing.

The first part of the The Art finishes with some strategies for simultaneous games. These are to look for dominant strategies where they are available, i.e they are the best strategy regardless of what the other players do. If this isn’t possible eliminate dominated strategies, i.e. those which are always beaten by your opponent. Nash equilibria are those moves which could not be improved, even given knowledge of an opponents moves. There can be multiple Nash equilibria in a game, which means if strategies are not explicitly stated the the players must guess which strategy the other player is using and act accordingly. This section also covers how social context influences play, and ideas of “punishment”.

The second part of the book looks at how the strategies described in the first part are used in action, although these examples are sometimes somewhat hypothetical. This part also introduces randomness (called “mixed strategies”) as a component of strategies.

The final part of the book covers applications of game theory in the real world, including auctions, bargaining and voting. I was interested to learn of the several sorts of auction, the English, Dutch, Japanese and Vickrey. The English auction is perhaps the one we are the most familiar with, participants signal when they wish to make a bid, and the bid rises with time. The Japanese auction is similar in that the bid is always rising but in this case all bidders start in the auction with their hands raised (indicating they are bidding) and put their hands down when the price is too high. A Dutch auction is one in which the price starts high, and drops, the winner is the one who first makes a bid. Finally, a Vickrey auction is a sealed-bid auction where the winner is the one the makes the highest bid, but they pay the second highest value.

Auctions are big money, the UK 3G spectrum auction in 2000 raised £22.5 billion from the participants. It’s worth spending some money to get the very best game theorists to help if you are participating in such an auction. The section on bargaining is relevant in the UK at the moment given the Brexit negotiations, particularly the idea of the Best Alternative to a Negotiated Agreement (BATNA). Players must determine their pay off relative to the BATNA, and must convince their opponents that the BATNA is as good as possible.  

I found the brief descriptions of  concrete applications of game theory such as in the various “spectrum” auctions for mobile phone systems, and the formation of price fixing cartels the most compelling part of the book.

Game theory is a central topic in at least parts of economics, as witnessed by the award of the pseudo-Nobel Prize for Economics in this area – there is a handy list here (http://lcm.csa.iisc.ernet.in/gametheory/nobel.html), if you are interested.

The Art of Strategy has some overlap with books I have read previously, the decision tree/game trees have some relevance to Risk Assessment and Decision Analysis with Bayesian Networks by Fenton and Neil (which uses the Monty Hall problem as an illustration). The Undercover Economist by Tim Harford discusses game theory and its relevance to the mobile frequency auctions in the UK, as well as the example of information in buying second hand cars. The Signal and the Noise by Nate Silver has some discussion of gaming statistics.

Scala – installation behind a workplace web proxy

I’ve been learning Scala as part of my continuing professional development. Scala is a functional language which runs primarily on the Java Runtime Environment. It is a first class citizen for working with Apache Spark – an important platform for data science. My intention in learning Scala is to get myself thinking in a more functional programming style and to gain easy access to Java-based libraries and ecosystems, typically I program in Python.

In this post I describe how to get Scala installed and functioning on a workplace laptop, along with its dependency manager, sbt. The core issue here is that my laptop at work puts me behind a web proxy so that sbt does not Just Work™. I figure this is a common problem so I thought I’d write my experience down for the benefit of others, including my future self.

The test system in this case was a relatively recent (circa 2015) Windows 7 laptop, I like using bash as my shell on Windows rather than the Windows Command Prompt – I install this using the Git for Windows SDK.

Scala can be installed from the Scala website https://www.scala-lang.org/download/. For our purposes we will use the  Windows binaries since the sbt build tool requires additional configuration to work. Scala needs the Java JDK version 1.8 to install and the JAVA_HOME needs to point to the appropriate place. On my laptop this is:

JAVA_HOME=C:\Program Files (x86)\Java\jdk1.8.0_131

The Java version can be established using the command:

javac –version

My Scala version is 2.12.2, obtained using:

scala -version

Sbt is the dependency manager and build tool for Scala, it is a separate install from:

http://www.scala-sbt.org/0.13/docs/Setup.html

It is possible the PATH environment variable will need to be updated manually to include the sbt executables (:/c/Program Files (x86)/sbt/bin).

I am a big fan of Visual Studio Code, so I installed the Scala helper for Visual Studio Code:

https://marketplace.visualstudio.com/items?itemName=dragos.scala-lsp

This requires a modification to the sbt config file which is described here:

http://ensime.org/build_tools/sbt/

Then we can write a trivial Scala program like:

object HelloWorld {

 

def main(args: Array[String]): Unit = {

 

    println(“Hello, world!”)

 

  }

 

}

And run it at the commandline with:

scala first.scala

To use sbt in my workplace requires proxies to be configured. The symptom of a failure to do this is that the sbt compile command fails to download the appropriate dependencies on first run, as defined in a build.sbt file, producing a line in the log like this:

[error] Server access Error: Connection reset url=https://repo1.maven.org/maven2/net/
sourceforge/htmlcleaner/htmlcleaner/2.4/htmlcleaner-2.4.pom

In my case I established the appropriate proxy configuration from the Google Chrome browser:

chrome://net-internals/#proxy

This shows a link to the pacfile, something like:

http://pac.madeupbit.com/proxy.pac?p=somecode

The PAC file can be inspected to identify the required proxy, in my this case there is a statement towards the end of the pacfile which contains the URL and port required for the proxy:

if (url.substring(0, 5) == ‘http:’ || url.substring(0, 6) == ‘https:’ || url.substring(0, 3) == ‘ws:’ || url.substring(0, 4) == ‘wss:’)

{

return ‘PROXY longproxyhosturl.com :80’;

}

 

These are added to a SBT_OPTS environment variable which can either be set in a bash-like .profile file or using the Windows environment variable setup.

export SBT_OPTS=”-Dhttps.proxyHost=longproxyhosturl.com -Dhttps.proxyPort=80 -Dhttps.proxySet=true”

As a bonus, if you want to use Java’s Maven dependency management tool you can use the same proxy settings but put them in a MAVEN_OPTS environment variable.

Typically to start a new project in Scala one uses the sbt new command with a pointer to a g8 template, in my workplace this does not work as normally stated because it uses the github protocol which is blocked by default (it runs on port 9418). The normal new command in sbt looks like:

sbt new scala/scala-seed.g8

The workaround for this is to specify the g8 repo in full including the https prefix:

sbt new https://github.com/scala/scala-seed.g8

This should initialise a new project, creating a whole bunch of standard directories.

So far I’ve completed one small project in Scala. Having worked mainly in dynamically typed languages it was nice that, once I had properly defined my types and got my program to compile, it ran without obvious error. I was a bit surprised to find no standard CSV reading / writing library as there is for Python. My Python has become a little more functional as a result of my Scala programming, I’m now a bit more likely to map a function over a list rather than loop over the list explicitly.

I’ve been developing intensively in Python over the last couple of years, and this seems to have helped me in configuring my Scala environment in terms of getting to grips with module/packaging, dependency managers, automated doocumentation building and also in finding my test library (http://www.scalatest.org/) at an early stage.