[WIP] Minimax search function (#71)

* Game trait created.

* parameter error resolved

* removed implicit parameter

* added missing isTerminalState function

* minimaxsearch added

* 1st requested change

case a :: Nil used instead to improve consistency with other cases.

* 2nd, 3rd, 4th, 5th, 6th requested changes made, errors resolved

Integrated all requested changes and remedied handful of syntactical and logical errors.

* added test problem for minimax

* test added

test spec for minimax

* reformatting

* shanges

changes

* review changes

* errors fixed, spec added

* clean

Co-authored-by: Shawn Garner <[email protected]>

Author: a1shadows

core/src/main/scala/aima/core/search/adversarial/Game.scala

@@ -1,14 +1,27 @@
 package aima.core.search.adversarial
 
-final case class UtilityValue(value: Double) extends AnyVal
+final case class UtilityValue(value: Double) extends AnyVal {
+  def <(that: UtilityValue)  = if (this.value < that.value) true else false
+  def >(that: UtilityValue)  = if (this.value > that.value) true else false
+  def ==(that: UtilityValue) = if (this.value == that.value) true else false
+
+}
 
 /**
   * @author Aditya Lahiri
+  * @author Shawn Garner
   */
-trait Game[Player, State, Action] {
-  def initialState: State
-  def getPlayer(state: State): Player
-  def getActions(state: State): List[Action]
-  def result(state: State, action: Action): State
-  def getUtility(state: State, player: Player): UtilityValue
+trait Game[P <: Player, S <: State, A <: Action] {
+  def initialState: S
+  def getPlayer(state: S): P
+  def getActions(state: S): List[A]
+  def result(state: S, action: A): S
+  def isTerminalState(state: S): Boolean
+  def getUtility(state: S): UtilityValue
 }
+
+trait Player {}
+
+trait State {}
+
+trait Action {}

core/src/main/scala/aima/core/search/adversarial/MinimaxSearch.scala

@@ -0,0 +1,50 @@
+package aima.core.search.adversarial
+
+import scala.annotation.tailrec
+
+/**
+  * @author Aditya Lahiri
+  * @author Shawn Garner
+  */
+object MinimaxDecision {
+  def minMaxDecision[PLAYER <: Player, STATE <: State, ACTION <: Action](
+      g: Game[PLAYER, STATE, ACTION],
+      noAction: ACTION
+  ): (STATE) => ACTION = { (state: STATE) =>
+    @tailrec def maxMinValue(Actions: List[ACTION]): ACTION = Actions match {
+      case Nil                   => noAction
+      case singularAction :: Nil => singularAction
+      case action1 :: action2 :: rest =>
+        maxMinValue(
+          (if (minValue(g.result(state, action1)) > minValue(g.result(state, action2))) action1
+           else action2) :: rest
+        )
+    }
+
+    @tailrec def minMaxValue(Actions: List[ACTION]): ACTION = Actions match {
+      case Nil                   => noAction
+      case singularAction :: Nil => singularAction
+      case action1 :: action2 :: rest =>
+        minMaxValue(
+          (if (maxValue(g.result(state, action1)) < maxValue(g.result(state, action2))) action1
+           else action2) :: rest
+        )
+    }
+
+    def maxValue(state: STATE): UtilityValue = {
+      if (g.isTerminalState(state))
+        g.getUtility(state)
+      else
+        minValue(g.result(state, maxMinValue(g.getActions(state))))
+    }
+
+    def minValue(state: STATE): UtilityValue = {
+      if (g.isTerminalState(state))
+        g.getUtility(state)
+      else
+        maxValue(g.result(state, minMaxValue(g.getActions(state))))
+    }
+
+    maxMinValue(g.getActions(g.initialState))
+  }
+}

core/src/main/scala/aima/core/search/problems/TwoPlyGame.scala

@@ -0,0 +1,70 @@
+package aima.core.search.problems
+
+import aima.core.search.adversarial._
+
+/**
+  * @author Aditya Lahiri
+  */
+case class TwoPlyPlayer(name: String) extends Player
+
+case class TwoPlyState(name: String)  extends State
+case class TwoPlyAction(name: String) extends Action
+
+object TwoPlyGame extends Game[TwoPlyPlayer, TwoPlyState, TwoPlyAction] {
+  val adjacencyMat = Map(
+    "A" -> List(TwoPlyAction("B"), TwoPlyAction("C"), TwoPlyAction("D")),
+    "B" -> List(TwoPlyAction("E"), TwoPlyAction("F"), TwoPlyAction("G")),
+    "C" -> List(TwoPlyAction("H"), TwoPlyAction("I"), TwoPlyAction("J")),
+    "D" -> List(TwoPlyAction("K"), TwoPlyAction("L"), TwoPlyAction("M"))
+  )
+  val TwoPlyStates = Map(
+    "A" -> TwoPlyState("A"),
+    "B" -> TwoPlyState("B"),
+    "C" -> TwoPlyState("C"),
+    "D" -> TwoPlyState("D"),
+    "E" -> TwoPlyState("E"),
+    "F" -> TwoPlyState("F"),
+    "G" -> TwoPlyState("G"),
+    "H" -> TwoPlyState("H"),
+    "I" -> TwoPlyState("I"),
+    "J" -> TwoPlyState("J"),
+    "K" -> TwoPlyState("K"),
+    "L" -> TwoPlyState("L"),
+    "M" -> TwoPlyState("M")
+  )
+
+  @Override
+  def initialState: TwoPlyState = TwoPlyStates("A")
+
+  @Override
+  def getPlayer(state: TwoPlyState): TwoPlyPlayer = state.name match {
+    case "B" | "C" | "D" => TwoPlyPlayer("MIN")
+    case _               => TwoPlyPlayer("MAX")
+  }
+
+  @Override
+  def getActions(state: TwoPlyState): List[TwoPlyAction] = adjacencyMat(state.name)
+
+  @Override
+  def result(state: TwoPlyState, action: TwoPlyAction): TwoPlyState = TwoPlyStates(action.name)
+
+  @Override
+  def isTerminalState(state: TwoPlyState): Boolean = state.name match {
+    case "A" | "B" | "C" | "D" => false
+    case _                     => true
+
+  }
+
+  @Override
+  def getUtility(state: TwoPlyState): UtilityValue = state.name match {
+    case "E" => UtilityValue(3)
+    case "F" => UtilityValue(12)
+    case "G" => UtilityValue(8)
+    case "H" => UtilityValue(2)
+    case "I" => UtilityValue(4)
+    case "J" => UtilityValue(6)
+    case "K" => UtilityValue(14)
+    case "L" => UtilityValue(5)
+    case "M" => UtilityValue(2)
+  }
+}

core/src/test/scala/aima/core/search/adversarial/MinimaxSearchSpec.scala

@@ -0,0 +1,44 @@
+package aima.core.search.adversarial
+
+import aima.core.search.problems.{TwoPlyPlayer, TwoPlyState, TwoPlyAction, TwoPlyGame}
+import org.specs2.mutable.Specification
+
+class MinimaxSearchSpec extends Specification {
+  "Utility value of E" should {
+    "be 3" in {
+      TwoPlyGame.getUtility(TwoPlyState("E")) must beEqualTo(UtilityValue(3))
+    }
+  }
+
+  "Utility value of I" should {
+    "be 4" in {
+      TwoPlyGame.getUtility(TwoPlyState("I")) must beEqualTo(UtilityValue(4))
+    }
+  }
+  "Utility value of K" should {
+    "be 14" in {
+      TwoPlyGame.getUtility(TwoPlyState("K")) must beEqualTo(UtilityValue(14))
+    }
+  }
+
+  "Initial State" should {
+    "be A" in {
+      TwoPlyGame.initialState must beEqualTo(TwoPlyState("A"))
+    }
+  }
+
+  "First player in the game" should {
+    "be MAX" in {
+      TwoPlyGame.getPlayer(TwoPlyGame.initialState) must beEqualTo(TwoPlyPlayer("MAX"))
+    }
+  }
+
+  "State to move to from intial state" should {
+    "be B" in {
+      MinimaxDecision.minMaxDecision[TwoPlyPlayer, TwoPlyState, TwoPlyAction](
+        TwoPlyGame,
+        TwoPlyAction("noAction")
+      )(TwoPlyGame.initialState) must beEqualTo(TwoPlyAction("B"))
+    }
+  }
+}