Basic concepts

In this unit we will introduce the main terminology, the concepts of Mixed strategies and equilibrium, in particular the Nash equilibrium.

As we will use Julia to explain the concepts, let's first set up some stuff, like working on a environment specific for these notes instead of using a global environment. We'll do this at the beginning of each chapter. If you need help in setting up or using Julia you can refer to my tutorial here.

using Pkg
cd(@__DIR__)
Pkg.activate(".")
# And let's install the companion package "StrategicGames" from https://github.com/sylvaticus/StrategicGames.jl
Pkg.add("StrategicGames")
using LinearAlgebra, StrategicGames

  Activating project at `~/work/GameTheoryNotes/GameTheoryNotes/buildedPages`
    Updating registry at `~/.julia/registries/General.toml`
   Resolving package versions...
   Installed GPUArraysCore ──────────────────── v0.1.4
   Installed RealDot ────────────────────────── v0.1.0
   Installed SIMDTypes ──────────────────────── v0.1.0
   Installed Calculus ───────────────────────── v0.5.1
   Installed JLD2 ───────────────────────────── v0.4.31
   Installed BitTwiddlingConvenienceFunctions ─ v0.1.5
   Installed IRTools ────────────────────────── v0.4.9
   Installed IrrationalConstants ────────────── v0.2.2
   Installed ScientificTypesBase ────────────── v3.0.0
   Installed DiffRules ──────────────────────── v1.13.0
   Installed MutableArithmetics ─────────────── v1.2.3
   Installed Adapt ──────────────────────────── v3.6.1
   Installed OffsetArrays ───────────────────── v1.12.9
   Installed StableRNGs ─────────────────────── v1.0.0
   Installed DualNumbers ────────────────────── v0.6.8
   Installed Rmath ──────────────────────────── v0.7.1
   Installed HypergeometricFunctions ────────── v0.3.15
   Installed MLJModelInterface ──────────────── v1.8.0
   Installed CpuId ──────────────────────────── v0.3.1
   Installed VectorizationBase ──────────────── v0.21.64
   Installed LayoutPointers ─────────────────── v0.1.14
   Installed GLPK_jll ───────────────────────── v5.0.1+0
   Installed MUMPS_seq_jll ──────────────────── v500.500.101+0
   Installed StatisticalTraits ──────────────── v3.2.0
   Installed TableTraits ────────────────────── v1.0.1
   Installed StatsFuns ──────────────────────── v1.3.0
   Installed DiffResults ────────────────────── v1.1.0
   Installed BetaML ─────────────────────────── v0.9.6
   Installed Bzip2_jll ──────────────────────── v1.0.8+0
   Installed CodecBzip2 ─────────────────────── v0.7.2
   Installed SpecialFunctions ───────────────── v2.2.0
   Installed BenchmarkTools ─────────────────── v1.3.2
   Installed Ipopt ──────────────────────────── v1.2.1
   Installed CategoricalArrays ──────────────── v0.10.7
   Installed IfElse ─────────────────────────── v0.1.1
   Installed StrategicGames ─────────────────── v0.0.4
   Installed CPUSummary ─────────────────────── v0.2.2
   Installed PDMats ─────────────────────────── v0.11.17
   Installed Tables ─────────────────────────── v1.10.1
   Installed DataAPI ────────────────────────── v1.14.0
   Installed JuMP ───────────────────────────── v1.10.0
   Installed LoopVectorization ──────────────── v0.12.157
   Installed ProgressMeter ──────────────────── v1.7.2
   Installed AbstractFFTs ───────────────────── v1.3.1
   Installed Literate ───────────────────────── v2.14.0
   Installed StaticArrays ───────────────────── v1.5.21
   Installed StaticArraysCore ───────────────── v1.4.0
   Installed Zygote ─────────────────────────── v0.6.60
   Installed JLLWrappers ────────────────────── v1.4.1
   Installed NaNMath ────────────────────────── v1.0.2
   Installed IteratorInterfaceExtensions ────── v1.0.0
   Installed ArrayInterfaceCore ─────────────── v0.1.29
   Installed DataValueInterfaces ────────────── v1.0.0
   Installed LLVMExtra_jll ──────────────────── v0.0.21+0
   Installed HostCPUFeatures ────────────────── v0.1.14
   Installed StructArrays ───────────────────── v0.6.15
   Installed AbstractTrees ──────────────────── v0.4.4
   Installed OrderedCollections ─────────────── v1.6.0
   Installed ThreadingUtilities ─────────────── v0.5.1
   Installed TranscodingStreams ─────────────── v0.9.12
   Installed ManualMemory ───────────────────── v0.1.8
   Installed CEnum ──────────────────────────── v0.4.2
   Installed Combinatorics ──────────────────── v1.0.2
   Installed ChainRulesCore ─────────────────── v1.15.7
   Installed FileIO ─────────────────────────── v1.16.0
   Installed PolyesterWeave ─────────────────── v0.2.1
   Installed ArrayInterface ─────────────────── v7.4.3
   Installed Ipopt_jll ──────────────────────── v300.1400.1000+0
   Installed Reexport ───────────────────────── v1.2.2
   Installed ForceImport ────────────────────── v0.0.3
   Installed QuadGK ─────────────────────────── v2.8.2
   Installed FillArrays ─────────────────────── v1.0.0
   Installed GPUArrays ──────────────────────── v8.6.6
   Installed OpenBLAS32_jll ─────────────────── v0.3.17+0
   Installed Rmath_jll ──────────────────────── v0.4.0+0
   Installed LogExpFunctions ────────────────── v0.3.23
   Installed CommonSubexpressions ───────────── v0.3.0
   Installed DataStructures ─────────────────── v0.18.13
   Installed Requires ───────────────────────── v1.3.0
   Installed ForwardDiff ────────────────────── v0.10.35
   Installed ChainRules ─────────────────────── v1.48.0
   Installed ZygoteRules ────────────────────── v0.2.3
   Installed Distributions ──────────────────── v0.25.87
   Installed HiGHS_jll ──────────────────────── v1.5.1+0
   Installed CloseOpenIntervals ─────────────── v0.1.12
   Installed Static ─────────────────────────── v0.8.6
   Installed ASL_jll ────────────────────────── v0.1.3+0
   Installed StatsAPI ───────────────────────── v1.6.0
   Installed MacroTools ─────────────────────── v0.5.10
   Installed Compat ─────────────────────────── v4.6.1
   Installed SLEEFPirates ───────────────────── v0.6.38
   Installed OpenSpecFun_jll ────────────────── v0.5.5+0
   Installed METIS_jll ──────────────────────── v5.1.2+0
   Installed UnPack ─────────────────────────── v1.0.2
   Installed CodecZlib ──────────────────────── v0.7.1
   Installed InverseFunctions ───────────────── v0.1.8
   Installed HiGHS ──────────────────────────── v1.5.1
   Installed StaticArrayInterface ───────────── v1.3.1
   Installed SortingAlgorithms ──────────────── v1.1.0
   Installed Missings ───────────────────────── v1.1.0
   Installed ChangesOfVariables ─────────────── v0.1.6
   Installed DensityInterface ───────────────── v0.4.0
   Installed GLPK ───────────────────────────── v1.1.1
   Installed StatsBase ──────────────────────── v0.33.21
   Installed LLVM ───────────────────────────── v5.0.0
   Installed MathOptInterface ───────────────── v1.14.1
    Updating `~/work/GameTheoryNotes/GameTheoryNotes/buildedPages/Project.toml`
  [024491cd] + BetaML v0.9.6
  [861a8166] + Combinatorics v1.0.2
  [e30172f5] + Documenter v0.27.24
  [60bf3e95] + GLPK v1.1.1
  [87dc4568] + HiGHS v1.5.1
  [b6b21f68] + Ipopt v1.2.1
  [4076af6c] + JuMP v1.10.0
  [98b081ad] + Literate v2.14.0
  [21c4ae29] + StrategicGames v0.0.4
    Updating `~/work/GameTheoryNotes/GameTheoryNotes/buildedPages/Manifest.toml`
  [a4c015fc] + ANSIColoredPrinters v0.0.1
  [621f4979] + AbstractFFTs v1.3.1
  [1520ce14] + AbstractTrees v0.4.4
  [79e6a3ab] + Adapt v3.6.1
  [4fba245c] + ArrayInterface v7.4.3
  [30b0a656] + ArrayInterfaceCore v0.1.29
  [6e4b80f9] + BenchmarkTools v1.3.2
  [024491cd] + BetaML v0.9.6
  [62783981] + BitTwiddlingConvenienceFunctions v0.1.5
  [fa961155] + CEnum v0.4.2
  [2a0fbf3d] + CPUSummary v0.2.2
  [49dc2e85] + Calculus v0.5.1
  [324d7699] + CategoricalArrays v0.10.7
  [082447d4] + ChainRules v1.48.0
  [d360d2e6] + ChainRulesCore v1.15.7
  [9e997f8a] + ChangesOfVariables v0.1.6
  [fb6a15b2] + CloseOpenIntervals v0.1.12
  [523fee87] + CodecBzip2 v0.7.2
  [944b1d66] + CodecZlib v0.7.1
  [861a8166] + Combinatorics v1.0.2
  [bbf7d656] + CommonSubexpressions v0.3.0
  [34da2185] + Compat v4.6.1
  [adafc99b] + CpuId v0.3.1
  [9a962f9c] + DataAPI v1.14.0
  [864edb3b] + DataStructures v0.18.13
  [e2d170a0] + DataValueInterfaces v1.0.0
  [b429d917] + DensityInterface v0.4.0
  [163ba53b] + DiffResults v1.1.0
  [b552c78f] + DiffRules v1.13.0
  [31c24e10] + Distributions v0.25.87
  [ffbed154] + DocStringExtensions v0.9.3
  [e30172f5] + Documenter v0.27.24
  [fa6b7ba4] + DualNumbers v0.6.8
  [5789e2e9] + FileIO v1.16.0
  [1a297f60] + FillArrays v1.0.0
  [9dda63f9] + ForceImport v0.0.3
  [f6369f11] + ForwardDiff v0.10.35
  [60bf3e95] + GLPK v1.1.1
  [0c68f7d7] + GPUArrays v8.6.6
  [46192b85] + GPUArraysCore v0.1.4
  [87dc4568] + HiGHS v1.5.1
  [3e5b6fbb] + HostCPUFeatures v0.1.14
  [34004b35] + HypergeometricFunctions v0.3.15
  [b5f81e59] + IOCapture v0.2.2
  [7869d1d1] + IRTools v0.4.9
  [615f187c] + IfElse v0.1.1
  [3587e190] + InverseFunctions v0.1.8
  [b6b21f68] + Ipopt v1.2.1
  [92d709cd] + IrrationalConstants v0.2.2
  [82899510] + IteratorInterfaceExtensions v1.0.0
  [033835bb] + JLD2 v0.4.31
  [692b3bcd] + JLLWrappers v1.4.1
  [682c06a0] + JSON v0.21.4
  [4076af6c] + JuMP v1.10.0
  [929cbde3] + LLVM v5.0.0
  [10f19ff3] + LayoutPointers v0.1.14
  [98b081ad] + Literate v2.14.0
  [2ab3a3ac] + LogExpFunctions v0.3.23
  [bdcacae8] + LoopVectorization v0.12.157
  [e80e1ace] + MLJModelInterface v1.8.0
  [1914dd2f] + MacroTools v0.5.10
  [d125e4d3] + ManualMemory v0.1.8
  [b8f27783] + MathOptInterface v1.14.1
  [e1d29d7a] + Missings v1.1.0
  [d8a4904e] + MutableArithmetics v1.2.3
  [77ba4419] + NaNMath v1.0.2
  [6fe1bfb0] + OffsetArrays v1.12.9
  [bac558e1] + OrderedCollections v1.6.0
  [90014a1f] + PDMats v0.11.17
  [69de0a69] + Parsers v2.5.8
  [1d0040c9] + PolyesterWeave v0.2.1
  [21216c6a] + Preferences v1.3.0
  [92933f4c] + ProgressMeter v1.7.2
  [1fd47b50] + QuadGK v2.8.2
  [c1ae055f] + RealDot v0.1.0
  [189a3867] + Reexport v1.2.2
  [ae029012] + Requires v1.3.0
  [79098fc4] + Rmath v0.7.1
  [94e857df] + SIMDTypes v0.1.0
  [476501e8] + SLEEFPirates v0.6.38
  [30f210dd] + ScientificTypesBase v3.0.0
  [66db9d55] + SnoopPrecompile v1.0.3
  [a2af1166] + SortingAlgorithms v1.1.0
  [276daf66] + SpecialFunctions v2.2.0
  [860ef19b] + StableRNGs v1.0.0
  [aedffcd0] + Static v0.8.6
  [0d7ed370] + StaticArrayInterface v1.3.1
  [90137ffa] + StaticArrays v1.5.21
  [1e83bf80] + StaticArraysCore v1.4.0
  [64bff920] + StatisticalTraits v3.2.0
  [82ae8749] + StatsAPI v1.6.0
  [2913bbd2] + StatsBase v0.33.21
  [4c63d2b9] + StatsFuns v1.3.0
  [21c4ae29] + StrategicGames v0.0.4
  [09ab397b] + StructArrays v0.6.15
  [3783bdb8] + TableTraits v1.0.1
  [bd369af6] + Tables v1.10.1
  [8290d209] + ThreadingUtilities v0.5.1
  [3bb67fe8] + TranscodingStreams v0.9.12
  [3a884ed6] + UnPack v1.0.2
  [3d5dd08c] + VectorizationBase v0.21.64
  [e88e6eb3] + Zygote v0.6.60
  [700de1a5] + ZygoteRules v0.2.3
  [ae81ac8f] + ASL_jll v0.1.3+0
  [6e34b625] + Bzip2_jll v1.0.8+0
  [e8aa6df9] + GLPK_jll v5.0.1+0
  [8fd58aa0] + HiGHS_jll v1.5.1+0
  [9cc047cb] + Ipopt_jll v300.1400.1000+0
  [dad2f222] + LLVMExtra_jll v0.0.21+0
  [d00139f3] + METIS_jll v5.1.2+0
  [d7ed1dd3] + MUMPS_seq_jll v500.500.101+0
⌅ [656ef2d0] + OpenBLAS32_jll v0.3.17+0
  [efe28fd5] + OpenSpecFun_jll v0.5.5+0
  [f50d1b31] + Rmath_jll v0.4.0+0
  [0dad84c5] + ArgTools v1.1.1
  [56f22d72] + Artifacts
  [2a0f44e3] + Base64
  [ade2ca70] + Dates
  [8bb1440f] + DelimitedFiles
  [8ba89e20] + Distributed
  [f43a241f] + Downloads v1.6.0
  [7b1f6079] + FileWatching
  [9fa8497b] + Future
  [b77e0a4c] + InteractiveUtils
  [4af54fe1] + LazyArtifacts
  [b27032c2] + LibCURL v0.6.3
  [76f85450] + LibGit2
  [8f399da3] + Libdl
  [37e2e46d] + LinearAlgebra
  [56ddb016] + Logging
  [d6f4376e] + Markdown
  [a63ad114] + Mmap
  [ca575930] + NetworkOptions v1.2.0
  [44cfe95a] + Pkg v1.8.0
  [de0858da] + Printf
  [9abbd945] + Profile
  [3fa0cd96] + REPL
  [9a3f8284] + Random
  [ea8e919c] + SHA v0.7.0
  [9e88b42a] + Serialization
  [6462fe0b] + Sockets
  [2f01184e] + SparseArrays
  [10745b16] + Statistics
  [4607b0f0] + SuiteSparse
  [fa267f1f] + TOML v1.0.0
  [a4e569a6] + Tar v1.10.1
  [8dfed614] + Test
  [cf7118a7] + UUIDs
  [4ec0a83e] + Unicode
  [e66e0078] + CompilerSupportLibraries_jll v1.0.1+0
  [781609d7] + GMP_jll v6.2.1+2
  [deac9b47] + LibCURL_jll v7.84.0+0
  [29816b5a] + LibSSH2_jll v1.10.2+0
  [c8ffd9c3] + MbedTLS_jll v2.28.0+0
  [14a3606d] + MozillaCACerts_jll v2022.2.1
  [4536629a] + OpenBLAS_jll v0.3.20+0
  [05823500] + OpenLibm_jll v0.8.1+0
  [83775a58] + Zlib_jll v1.2.12+3
  [8e850b90] + libblastrampoline_jll v5.1.1+0
  [8e850ede] + nghttp2_jll v1.48.0+0
  [3f19e933] + p7zip_jll v17.4.0+0
        Info Packages marked with ⌅ have new versions available but compatibility constraints restrict them from upgrading. To see why use `status --outdated -m`
    Building BetaML → `~/.julia/scratchspaces/44cfe95a-1eb2-52ea-b672-e2afdf69b78f/151d340275c02bb9754cdb66f576fe4d856c2405/build.log`
Precompiling project...
  ✓ Compat
  ✓ Calculus
  ✓ Combinatorics
  ✓ OrderedCollections
  ✓ Requires
  ✓ UnPack
  ✓ CpuId
  ✓ DataValueInterfaces
  ✓ ScientificTypesBase
  ✓ RealDot
  ✓ StableRNGs
  ✓ FillArrays
  ✓ OpenLibm_jll
  ✓ Reexport
  ✓ PDMats
  ✓ InverseFunctions
  ✓ SIMDTypes
  ✓ MbedTLS_jll
  ✓ Zlib_jll
  ✓ IfElse
  ✓ IteratorInterfaceExtensions
  ✓ AbstractTrees
  ✓ ForceImport
  ✓ DataAPI
  ✓ IrrationalConstants
  ✓ StatsAPI
  ✓ CompilerSupportLibraries_jll
  ✓ GMP_jll
  ✓ CEnum
  ✓ ProgressMeter
  ✓ StaticArraysCore
  ✓ ManualMemory
  ✓ TranscodingStreams
  ✓ JLLWrappers
  ✓ MacroTools
  ✓ ArrayInterfaceCore
  ✓ BenchmarkTools
  ✓ Literate
  ✓ ChainRulesCore
  ✓ Adapt
  ✓ MutableArithmetics
  ✓ StatisticalTraits
  ✓ DataStructures
  ✓ NaNMath
  ✓ DensityInterface
  ✓ LibSSH2_jll
  ✓ TableTraits
  ✓ Static
  ✓ OpenBLAS_jll
  ✓ Missings
  ✓ FileIO
  ✓ DiffResults
  ✓ ThreadingUtilities
  ✓ CodecZlib
  ✓ Rmath_jll
  ✓ HiGHS_jll
  ✓ ASL_jll
  ✓ LLVMExtra_jll
  ✓ GLPK_jll
  ✓ Bzip2_jll
  ✓ OpenSpecFun_jll
  ✓ OpenBLAS32_jll
  ✓ METIS_jll
  ✓ CommonSubexpressions
  ✓ ZygoteRules
  ✓ ChangesOfVariables
  ✓ IRTools
  ✓ AbstractFFTs
  ✓ GPUArraysCore
  ✓ OffsetArrays
  ✓ ArrayInterface
  ✓ StaticArrays
  ✓ MLJModelInterface
  ✓ SortingAlgorithms
  ✓ BitTwiddlingConvenienceFunctions
  ✓ Tables
  ✓ QuadGK
  ✓ libblastrampoline_jll
  ✓ CPUSummary
  ✓ CategoricalArrays
  ✓ Rmath
  ✓ CodecBzip2
  ✓ LogExpFunctions
  ✓ StaticArrayInterface
  ✓ HostCPUFeatures
  ✓ LLVM
  ✓ MUMPS_seq_jll
  ✓ StructArrays
  ✓ PolyesterWeave
  ✓ StatsBase
  ✓ CloseOpenIntervals
  ✓ LayoutPointers
  ✓ SpecialFunctions
  ✓ Ipopt_jll
  ✓ GPUArrays
  ✓ JLD2
  ✓ DualNumbers
  ✓ DiffRules
  ✓ HypergeometricFunctions
  ✓ ChainRules
  ✓ ForwardDiff
  ✓ StatsFuns
  ✓ VectorizationBase
  ✓ Distributions
  ✓ SLEEFPirates
  ✓ Zygote
  ✓ LoopVectorization
  ✓ BetaML
  ✓ MathOptInterface
  ✓ GLPK
  ✓ HiGHS
  ✓ Ipopt
  ✓ JuMP
  ✓ StrategicGames
  114 dependencies successfully precompiled in 181 seconds. 8 already precompiled.

Basic definitions

Utility function:

• a mapping from a certain state of the world to a real number interpreted as measure of agent's happiness or satisfation
• it allows quantify preferences against different alternatives
• strictly speaking utility is an ordinal measure, not a cardinal one. When we apply an affine transformation (i.e. linear with eventually a constant, like $y = ax+c$) to the inputs of the utility function the ranking of the preferences doesn't change. As well the comparition of utilities between different agents doesn't change (if the utility of agent 1 was higher than those of agent 2 and we apply an affine transformation to the inputs, e.g. we change the measure units, the utility of agent 1 remains higher than those of agent 2).

Game :

• the situation arising from the interaction of multiple utility maximising agents

Noncooperative game:

• when the modelling unit is the (utility maximising) individual

Coalitional or cooperative games:

• when the modelling unit is the group

Normal form game:

• a game situation where each players play at the same time (no time dimension) and states of the word (utilities) depends only from the combined actions of all the players, without stochasticity (there could still be stochasticity in the choice of making decisions by the players)

Bayesian game:

• when the state of the world depends on stochasticity other than the players combined actions

Extensive-form games:

• include a timing dimension t that precises the order of the actions taken by the various players
• it becomes relevant the degree of information that the agents know at the times of making decisions

A (finite, N-person) normal-form game is characterized by the following elements:

• \[N\]

  is a finite (ordered) set of players indexed by $n$

• \[A_n\]

  is the (ordered) set of actions available to player $n$. Each player can have different actions available (including in different number). The total possible states of the world correspond to all the possible actions that all the $N$ players can take and it is given by the N-dimensional array $A$ of size $(length(A_1),length(A_2),...,length(A_n)$. Note that as there isn't any stocasticity here, there is no distintion between a given set of actions and the resulting state of the world.

• \[U\]

  is the utility levels associated to each corresponding state of the word, aka pay-off matrix ("array" would be a more appropriate word). This is a $N+1$ dimensional array of size $(length(A_1),length(A_2),...,length(A_n),N$. The last dimension has size $N$, as each player has its own utility functions of the various states of the world. Alternatively, $U$ can be represented as a N dimensional array of tuples representing each the utility of the various players for the given state of the world.

We can further define:

• \[S_n\]

  the (infinite) set of all the discrete probability functions that agent $n$ may want to use over its set of available actions $A_n$ in order to stocastically determine its action. Each individual probability distribution $s_{ni}$ is called strategy. Strategies $s_{ni}$ with a single action with non-zero probabilities are called pure strategies, while strategies with more than one available action assigned non-zero probabilities are called mixed strategies and strategies with non zero probabilities for all actions are named fully mixed straegies. The (sub)set of actions assigned non-zero probabilities is called support of the given strategy. We indicate with $s_{n}$ the strategy (PDF) emploied by player $n$ and with $s$ the strategy profile, the set of all particular strategies applied by all the individual players.

• \[a_{length(A_1),length(A_2),...,length(A_n)}\]

  are the individual states of the world (the elements of the $A$ array) derived by the combined actions of all the $1,2,...,N$ players. These are also called an action profile.

• \[E[U(s_{ni})]\]

  The expected utility by player $n$ by employing strategy $s_{ni}$. Knowing (or assuming) the strategies emploied by the other players, the expected utility of a given strategy $i$ for player $n$ can be computed as $\sum_{a \in A} U_n(a) \prod_{j=1}^{N} s_j(a)$ that is it, for each state of the world $a$ we compute the probability (using the multiplication rule) that it arises using the strategies of all the players, including the one specific we are evaluating ($i$ of player $n$), and we multiply it by the utility this state provides to player $n$ and we finally sum all this "possible" state to retrieve the expected value.

Interpretation of mixed-strategies equilibrium

What does a mixed-strategy represents? Why should it be used ?

1. Confuse the opponent. In many competitive games (like the Head or Tail one) apply a pure strategy would imply the other player be able to exploit to its own advantage. It is only by applying a random (i.e. mixed) strategy that the opponent can't exploit your strategy
2. Uncertainty over other players' strategies. Under this interpretation, a mixed strategy of a given player is the assessment of all other players concerning how likely are his pure strategies taken individually. Further, every action in the support of a mixed strategy in a Nash equilibrium is a best response to the player beliefs about the other players’ strategies.
3. Empirical frequency. The entry of each action in a mixed strategy is the relative count on how often that action would be emploied in repeated games by the same players or with a different players selected at random from a hypothetical "player population"

Examples

N = 3            # 3 players
A = [3,2,2]      # 3, 2,and 2 actions available for players 1,2,3 respectively
U = rand(A...,N) # pay-off array
a = (2,1,2)      # one particular state of the world (action profile)
U[a...,2]        # The utility for player 2 associated to this particular state of the world - note that we select "2" on the last dimension

s1 = [0.5,0.3,0.2] # One particular mixed-strategy emploied by player 1
s2 = [0,1]         # One particular pure-strategy emploied by player 2
s3 = [0.5,0.5]     # One particular mixed-strategy emploied by partner 3

s = [s1,s2,s3]     # A strategy profile

# Expected utilities for the 3 players under strategy profile s:
expected_utility = [sum(U[i1,i2,i3,n] * s[1][i1] * s[2][i2] * s[3][i3] for i1 in 1:A[1], i2 in 1:A[2], i3 in 1:A[3]) for n in 1:N]
expected_utility = StrategicGames.expected_payoff(U,s) # equivalent from the library package

3-element Vector{Float64}:
 0.4986839859096396
 0.3041973608899715
 0.5107492773304352

Particular types of games

Common-playoff games:

• a type of game where, for each action profile, all players derive the same utility
• a "pure coordination" game: the players have no conflict interest and the only "difficulty" is for them to coordinate to get the maximum benefits

Zero-sum games (aka "constant-sum" games):

• a 2-players type of game where the sum of the utility for the 2 players for each action profile is constant
• a "pure competition" game, as if one action profile bring some additional advantage than the constant for the first player, this must be at the expenses of the other player
• as games are insensible to affine transformations, this constant isn't restricted to be zero, it can be any constant value

Prisoner-dilemma games:

• a classical 2-actions, 2-players game with:

• a pay-off structure like:

  p1 \ p2	A	B
  A	a,a	b,c
  B	c,b	d,d

  where the first element in the tuple of each action profile (cell) represents the utility for player 1 (row player) and the second element the utility for player 2 (column player)

• a numerical evaluation of $a,b,c,d$ such that $c > a$, $d > b$ and $a > d$, that is $c > a > d > b$

This game is partially cooperative and partially competitive. It can be seen that for each player, whatever the other player playes, it is always better to play B (for example for player 1, if player 2 plays A, $c$ is higher than $a$, and if player 2 plays B, $d$ is higher than $b$). The action B then dominates the other one for both the players even if they could coordinate they would be both better off by both choosing A. In other words, as everyone behaves as free rider, the best feasible state is never reached. This is a frequent situation in economics in relation to the production of public goods: everyone wants to share the benefit from it, but nobody wants to bring the costs of their production.

The name derives from the original situation used to illustrate the case, of two prigioniers that can choose to deny their common crime they are accused (A) or confess to the authority (B), where if one alone confesses, he get free of prison ($c$) but the other get a harsh prison term ($b$); if both confess they get a standard prison term (d) and if they both deny they got a mild prison term ($a$). The outcome of the game is that it is rational for both of them to confess !

Examples

A common pay-off game with 2 actions for the first player and 3 actions for the second player:

A constant-sum pay-off game with 2 actions for the first player and 3 actions for the second player:

A prisoner-dilemma problem:

Pareto optimality of a state of the world

When we put ourself as an outside observer we would like a criteria to decide which outomes are better than others. Under the pareto optimal criteria (bear in mind that economists prefer to use the word "efficient" rather than "optimal") a given strategy profile is optimal if there could not be a player that could be made better off from the resulting (expected) state of the world without another player being made worst, that is there are no pareto-dominated strategy profile where at least one player could improve its expected utility without the other loose anything under another strategy profile.

Pareto efficient solutions are not unique. They form instead a "frontier" of the utilities that the game can bring to the players.

In the figure below the two axis refer to the expected utilities for players 1 and 2, red points ($a,b,c$) refer to Pareto dominated strategy profiles; green points $d,e,f$, leaning on the efficient frontier, are Pareto optimal strategies and grey points $g,h$ are simply points impossible to obtain in the given game.

Example

The following table provides the expected utility for a 3-players game, each with two pure actions, and show which of them are on the frontier on the last column:

We can see that this game has 5 Pareto-optimal strategy profiles. The $(A,D,F)$ strategy is instead dominated by the $(B,E,G)$ one, the $(A,E,F)$ strategy is dominated by the $(A,D,F)$, $(A,E,G)$, $(B,D,F)$ and $(B,E,G)$ ones and finally the $(B,D,G)$ strategy is dominated by the $(A,E,G)$ one.

The prisoner-dilemma is an interesting example of how the equilibrium outcome (confess, confess) is the only Pareto-dominated outcome of the game.