# Efficient Nash Equilibria using JuMP

**URL:** <https://discourse.julialang.org/t/efficient-nash-equilibria-using-jump/57616>\
**Category:** Optimization (Mathematical)\
**Tags:** question, jump, performance\
**Created:** [March 20, 2021, 6:06pm UTC](https://discourse.julialang.org/t/efficient-nash-equilibria-using-jump/57616 "2021-03-20T18:06:40Z")\
**Posts on this page:** 1\
**Showing post:** 6

<div class="post-metadata">

**Author:** ![Ian\_Slagle](https://avatars.discourse-cdn.com/v4/letter/i/b5a626/32.png) [@Ian\_Slagle](https://discourse.julialang.org/u/Ian_Slagle)\
**Post date:** [March 21, 2021, 8:31pm UTC](https://discourse.julialang.org/t/efficient-nash-equilibria-using-jump/57616/6 "2021-03-21T20:31:19Z")

</div>

This is working beautifully. I went ahead and added some checks to save time on solutions with pure strategies, but even without this its still faster than LRSLib at the nxn matrices tested.

```julia
function strat_vec(l::Int64, i::Int64)
    vec_to_return = vec(zeros(l))
    @inbounds vec_to_return[i] = 1.0
    return vec_to_return
end

minmax(R::Array{Float64, 2}, m::Int64) = @inbounds mapreduce(x -> maximum(R[:, x]), min, 1:m)
maxmin(R::Array{Float64, 2}, n::Int64) = @inbounds mapreduce(x -> minimum(R[x, :]), max, 1:n)
findminmax(R::Array{Float64, 2}, n::Int64) = @inbounds strat_vec(n, argmax(map(x -> minimum(R[x, :]), 1:n)))
findmaxmin(R::Array{Float64, 2}, m::Int64) = @inbounds strat_vec(m, argmin(map(x -> maximum(R[:, x]), 1:m)))

function nash(R::Array{Float64, 2})
    n, m = size(R)
    
    # Check if we have to do linear programming
    n == 1 && return minimum(R), vec([1.0]), strat_vec(m, argmin(vec(R)))
    m == 1 && return maximum(R), strat_vec(n, argmin(vec(R))), vec([1.0])
    minmax(R, m) == maxmin(R, n) && return minmax(R, m), findminmax(R, n), findmaxmin(R, m)
    
    # Set up model and payoff
    model = direct_model(GLPK.Optimizer())
    @variable(model, z)
    @objective(model, Max, 1.0 * z)
    
    # Solve for row player
    @variable(model, x[1:n], lower_bound = 0.0)
    @constraint(model, c1, x' * R .>= z)
    @constraint(model, sum(x) == 1.0)
    
    optimize!(model)
    
    return value(z), value.(x), shadow_price.(c1)
end

```

 ![image](https://global.discourse-cdn.com/julialang/original/3X/3/8/38a1149ee2f511d5ab29fe1b0364f252d7a066ed.png)

---

_[View the full topic](https://discourse.julialang.org/t/efficient-nash-equilibria-using-jump/57616)._