Export lower and upper bounds of the game and strategy type (Pure or Mixed) in Game solver.

Author: jbytecode

CHANGELOG.md

@@ -1,6 +1,7 @@
 ### 0.2.13 (Upcoming Release)
 
 - Minimum Spanning Tree accepts distance matrix encapsulated by MstProblem as input.
+- Export lower and upper bounds of the game and strategy type (Pure or Mixed) in Game solver.
 
 ### 0.2.12 
 

docs/src/game.md

@@ -1,5 +1,10 @@
 # Zero-Sum Games
 
+## Strategy Type
+
+```@docs 
+OperationsResearchModels.StrategyType
+```
 
 ## Game Problem 
 

src/OperationsResearchModels.jl

@@ -89,7 +89,7 @@ import .Network: Connection, nodes
 import .MaximumFlow: MaximumFlowResult, MaximumFlowProblem
 import .MinimumCostFlow: MinimumCostFlowProblem, MinimumCostFlowResult
 import .Assignment: AssignmentProblem, AssignmentResult, isbalanced, balance
-import .Game: GameProblem, GameResult
+import .Game: GameProblem, GameResult, StrategyType, alpha, beta, strategytype, Pure, Mixed
 import .MinimumSpanningTree: hasloop, MstResult, MstProblem
 import .PMedian: pmedian, pmedian_with_distances, PMedianResult
 import .CPM: CpmActivity, earliestfinishtime, longestactivity, CpmProblem, CpmResult
@@ -109,7 +109,7 @@ export TransportationProblem,
 export Connection, ShortestPathResult, MaximumFlowResult, MinimumCostFlowResult, nodes
 export ShortestPathProblem, MaximumFlowProblem, MinimumCostFlowProblem
 export AssignmentProblem, AssignmentResult, isbalanced, balance
-export GameProblem, GameResult
+export GameProblem, GameResult, StrategyType, alpha, beta, strategytype, Pure, Mixed
 export hasloop, MstResult, MstProblem
 export pmedian, pmedian_with_distances, PMedianResult
 export CpmActivity, earliestfinishtime, longestactivity, CpmProblem, CpmResult

src/game.jl

@@ -5,6 +5,25 @@ using JuMP, HiGHS
 
 import ..OperationsResearchModels: solve
 
+export GameProblem
+export GameResult
+export StrategyType
+
+"""
+    StrategyType
+
+# Description
+
+An enumeration to represent the type of strategy in a game.
+
+- `Pure`: Indicates that the optimal strategy is pure, meaning that the player should choose one strategy with probability 1.
+- `Mixed`: Indicates that the optimal strategy is mixed, meaning that the player should randomize between multiple strategies with certain probabilities.
+"""
+@enum StrategyType begin
+    Pure
+    Mixed
+end
+
 
 """
     GameProblem 
@@ -34,12 +53,18 @@ A structure to hold the result of a game.
 - `probabilities`: Probabilities of the strategies
 - `value`:         Value of the game
 - `model::JuMP.Model`: The JuMP model used to solve the game.
+- `alpha::Float64`: The lower bound of the game value (maximin).
+- `beta::Float64`: The upper bound of the game value (minimax).
+- `strategytype::StrategyType`: Indicates whether the optimal strategy is pure or mixed.
 
 """
 struct GameResult
     probabilities::Any
     value::Any
     model::JuMP.Model
+    alpha::Float64
+    beta::Float64
+    strategytype::StrategyType
 end
 
 
@@ -134,10 +159,40 @@ function game_solver(gamematrix::Matrix{<:Real}; verbose::Bool = false)::GameRes
 
     gamevalue = JuMP.value(g) #objective_value(model)
 
-    result = GameResult(values, gamevalue, model)
+    a = alpha(GameProblem(gamematrix))
+    b = beta(GameProblem(gamematrix))
+    stype = strategytype(GameProblem(gamematrix))
+
+    result = GameResult(
+        values, 
+        gamevalue, 
+        model,
+        a,
+        b,
+        stype)
 
     return result
 
 end
 
+function alpha(problem::GameProblem)::Float64 
+    return maximum(minimum.(eachrow(problem.decisionMatrix)))
+end 
+
+function beta(problem::GameProblem)::Float64 
+    return minimum(maximum.(eachcol(problem.decisionMatrix)))
+end 
+
+function strategytype(problem::GameProblem)::StrategyType
+    a = alpha(problem)
+    b = beta(problem)
+    if a == b
+        return Pure
+    else
+        return Mixed
+    end
+end 
+
+
+
 end # end of module 

test/testgame.jl

@@ -22,6 +22,8 @@
             [0.4666667, 0.5333333, 0.0000000],
             atol = tol,
         )
+
+        @test result[1].strategytype == Mixed
     end
 
     @testset "Game - Rock & Paper & Scissors" begin
@@ -49,6 +51,10 @@
 
         @test isapprox(result[2].probabilities, [0.333333, 0.333333, 0.33333], atol = tol)
 
+        @test result[1].alpha == -1.0
+
+        @test result[1].beta == 1.0
+
     end
 
     @testset "Simple Game" begin
@@ -74,4 +80,36 @@
 
         @test isapprox(result[2].probabilities, [0.6, 0.4], atol = 0.00001)
     end
+
+
+    @testset "Pure Strategy Game" begin
+
+        mat = [
+            2 5
+            1 1
+        ]
+
+        problem = GameProblem(mat)
+
+        result = solve(problem)
+
+        @test isa(result, Vector{GameResult})
+
+        @test length(result) == 2
+
+        @test result[1].value == 2.0
+
+        # Best option is R1 - C1 
+        
+        @test isapprox(result[1].probabilities, [1.0, 0.0], atol = 0.00001)
+
+        @test isapprox(result[2].probabilities, [1.0, 0.0], atol = 0.00001)
+
+        @test result[1].strategytype == Pure
+
+        @test result[1].alpha == 2.0
+
+        @test result[1].beta == 2.0
+
+    end
 end