Game Playing in Artificial Intelligence
Game Playing is an important domain of artificial intelligence. Games don’t require much knowledge; the only knowledge we
need to provide is the rules, legal moves and the conditions of winning or losing the game. Both players try to win the game. So,
both of them try to make the best move possible at each turn
Mini-Max Algorithm in Artificial Intelligence
Mini-max algorithm is a recursive or backtracking algorithm which is used in decisionmaking and game theory. It provides an optimal move for the player assuming that
opponent is also playing optimally.
Mini-Max algorithm uses recursion to search through the game-tree.
Min-Max algorithm is mostly used for game playing in AI. Such as Chess, Checkers, tic-tactoe, go, and various tow-players game. This Algorithm computes the minimax decision for
the current state.
In this algorithm two players play the game, one is called MAX and other is called MIN.
Both the players fight it as the opponent player gets the minimum benefit while they get
the maximum benefit.
Both Players of the game are opponent of each other, where MAX will select the
maximized value and MIN will select the minimized value.
The minimax algorithm performs a depth-first search algorithm for the exploration of the
complete game tree.
The minimax algorithm proceeds all the way down to the terminal node of the tree, then
backtrack the tree as the recursion.
Pseudo-code for MinMax Algorithm:
1.function minimax(node, depth, maximizingPlayer) is
2.if depth ==0 or node is a terminal node then
3.return static evaluation of node
4.
5.if MaximizingPlayer then
// for Maximizer Player
6.maxEva= -infinity
7. for each child of node do
8. eva= minimax(child, depth-1, false)
9.maxEva= max(maxEva,eva)
//gives Maximum of the values
10.return maxEva
11.
12.else
// for Minimizer player
13. minEva= +infinity
14. for each child of node do
15. eva= minimax(child, depth-1, true)
16. minEva= min(minEva, eva)
//gives minimum of the values
17. return minEva
Initial call
Minimax(node, 3, true)
Working of Min-Max Algorithm
The working of the minimax algorithm can be easily described using an example. Below we have taken an example of game-tree
which is representing the two-player game.
In this example, there are two players one is called Maximizer and other is called Minimizer.
Maximizer will try to get the Maximum possible score, and Minimizer will try to get the minimum possible score.
This algorithm applies DFS, so in this game-tree, we have to go all the way through the leaves to reach the terminal nodes.
At the terminal node, the terminal values are given so we will compare those value and backtrack the tree until the initial state
occurs. Following are the main steps involved in solving the two-player game tree:
Step-1: In the first step, the algorithm generates the entire game-tree and apply the utility function to get the utility values for
the terminal states. In the below tree diagram, let's take A is the initial state of the tree. Suppose maximizer takes first turn which
has worst-case initial value =- infinity, and minimizer will take next turn which has worst-case initial value = +infinity.
Step 2: Now, first we find the utilities value for the Maximizer, its initial value is -∞, so we will compare each value in terminal
state with initial value of Maximizer and determines the higher nodes values. It will find the maximum among the all.
•For node D
•For Node E
•For Node F
•For node G
max(-1,- -∞) => max(-1,4)= 4
max(2, -∞) => max(2, 6)= 6
max(-3, -∞) => max(-3,-5) = -3
max(0, -∞) = max(0, 7) = 7
Step 3: In the next step, it's a turn for minimizer, so it will compare all nodes value with +∞, and will find the 3rd layer
node values.
•For node B= min(4,6) = 4
•For node C= min (-3, 7) = -3
Step 4: Now it's a turn for Maximizer, and it will again choose the maximum of all nodes value and find the maximum
value for the root node. In this game tree, there are only 4 layers, hence we reach immediately to the root node, but in
real games, there will be more than 4 layers.
•For node A max(4, -3)= 4
That was the complete workflow of the minimax two player game.
Properties of Mini-Max algorithm
Properties of Mini-Max algorithm:
Complete- Min-Max algorithm is Complete. It will definitely find a solution (if exist),
in the finite search tree.
Optimal- Min-Max algorithm is optimal if both opponents are playing optimally.
Time complexity- As it performs DFS for the game-tree, so the time complexity of
Min-Max algorithm is O(bm), where b is branching factor of the game-tree, and m
is the maximum depth of the tree.
Space Complexity- Space complexity of Mini-max algorithm is also similar to DFS
which is O(bm).
Alpha-Beta Pruning
The two-parameter can be defined as:
Alpha: The best (highest-value) choice we have found so far at any point along the
path of Maximizer. The initial value of alpha is -∞.
Beta: The best (lowest-value) choice we have found so far at any point along the
path of Minimizer. The initial value of beta is +∞.
The main condition which required for alpha-beta pruning is: α>=β
Key points about alpha-beta pruning:
The Max player will only update the value of alpha.
The Min player will only update the value of beta.
While backtracking the tree, the node values will be passed to upper nodes instead of values of alpha and beta.
We will only pass the alpha, beta values to the child nodes.
Pseudo-code for Alpha-beta Pruning
1. function minimax(node, depth, alpha, beta, maximizingPlayer) is
2. if depth ==0 or node is a terminal node then
3. return static evaluation of node
4.
5. if MaximizingPlayer then
// for Maximizer Player
6.
maxEva= -infinity
7.
for each child of node do
8.
eva= minimax(child, depth-1, alpha, beta, False)
9.
maxEva= max(maxEva, eva)
10. alpha= max(alpha, maxEva)
11. if beta<=alpha
12. break
13. return maxEva
14.
15.else
// for Minimizer player
16. minEva= +infinity
17. for each child of node do
18. eva= minimax(child, depth-1, alpha, beta, true)
19. minEva= min(minEva, eva)
20. beta= min(beta, eva)
21.
if beta<=alpha
22. break
23. return minEva
Move Ordering in Alpha-Beta pruning:
• Worst ordering: In some cases, alpha-beta pruning algorithm does not
prune any of the leaves of the tree, and works exactly as minimax
algorithm. In this case, it also consumes more time because of alpha-beta
factors, such a move of pruning is called worst ordering. In this case, the
best move occurs on the right side of the tree. The time complexity for
such an order is O(bm).
• Ideal ordering: The ideal ordering for alpha-beta pruning occurs when lots
of pruning happens in the tree, and best moves occur at the left side of the
tree. We apply DFS hence it first search left of the tree and go deep twice
Rules
find good ordering:
asto minimax
algorithm in the same amount of time. Complexity in ideal
ordering is O(bm/2).
Occur the best move from the shallowest node.
Order the nodes in the tree such that the best nodes are checked first.
Use domain knowledge while finding the best move. Ex: for Chess, try order: captures first, then threats, then forward
moves,
backward moves.
We can bookkeep the states, as there is a possibility that states may repeat.
Jug Problem in Artificial Intelligence
You are given two jugs, a 4-liter one and a 3-liter one. Neither has any measuring
markers on it. There is a pump that can be used to fill the jugs with water. How can
you get exactly 2 liters of water into a 4-liter jug.”
Representation of water Jug Problem in terms of state-space search
State: (x, y)
where x represents the quantity of water in a 4-liter jug and y represents the quantity of water in a 3-liter jug.
That is, x = 0, 1, 2, 3, or 4 y = 0, 1, 2, 3
Start state: (0, 0).
Goal state: (2, n) for any n.
Here need to start from the current state and end up in a goal state.
Production Rules for Water Jug Problem in Artificial Intelligence
1
2
(x, y) is X<4 ->(4, Y)
(x, y) if Y<3 -> (x, 3)
Fill the 4-liter jug
Fill the 3-liter jug
3
(x, y) if x>0 -> (x-d, d)
Pour some water out of the 4-liter jug.
4
(x, y) if Y>0 -> (d, y-d)
Pour some water out of the 3-liter jug.
5
(x, y) if x>0 -> (0, y)
Empty the 4-liter jug on the ground
6
(x, y) if y>0 -> (x,0)
Empty the 3-liter jug on the ground
7
(x, y) if X+Y >= 4 and y>0 -> (4, y-(4-x))
Pour water from the 3-liter jug into the 4-liter
jug until the 4-liter jug is full
8
(x, y) if X+Y>=3 and x>0 -> (x-(3-y), 3))
Pour water from the 4-liter jug into the 3-liter
jug until the 3-liter jug is full.
9
(x, y) if X+Y <=4 and y>0 -> (x+y, 0)
10
(x, y) if X+Y<=3 and x>0 -> (0, x+y)
11
(0, 2) -> (2, 0)
12
(2, Y) -> (0, y)
Pour all the water from the 3-liter jug into the 4liter jug.
Pour all the water from the 4-liter jug into the 3liter jug.
Pour the 2-liter water from the 3-liter jug into
the 4-liter jug.
Empty the 2-liter in the 4-liter jug on the
The solution to Water Jug Problem in Artificial Intelligence
Current state = (0, 0)
Loop until the goal state (2, 0) reached
– Apply a rule whose left side matches the current state
– Set the new current state to be the resulting state
(0, 0) – Start State
(0, 3) – Rule 2, Fill the 3-liter jug
(3, 0) – Rule 9, Pour all the water from the 3-liter jug into the 4-liter jug.
(3, 3) – Rule 2, Fill the 3-liter jug
(4, 2) – Rule 7, Pour water from the 3-liter jug into the 4-liter jug until the 4-liter jug
is full.
(0, 2) – Rule 5, Empty the 4-liter jug on the ground
(2, 0) – Rule 9, Pour all the water from the 3-liter jug into the 4-liter jug.
Goal State reached
Another solution to Water Jug Problem in Artificial Intelligence
(0, 0) – Start State
(4, 0) – Rule 1, Fill the 4-liter jug
(1, 3) – Rule 8, Pour water from the 4-liter jug into the 3-liter jug until the 3-liter jug is full.
(1, 0) – Rule 6, Empty the 3-liter jug on the ground
(0, 1) – Rule 10, Pour all the water from the 4-liter jug into the 3-liter jug.
(4, 1) – Rule 1, Fill the 4-liter jug
(2, 3) – Rule 8, Pour water from the 4-liter jug into the 3-liter jug until the 3-liter jug is full.
Goal State reached
Chess Problem in Artificial Intelligence
It is a normal chess game. In a chess problem, the start is the initial
configuration of chessboard. The final state is the any board configuration,
which is a winning position for any player. There may be multiple final
positions and each board configuration can be thought of as representing a
state of the game. Whenever any player moves any piece, it leads to
different state of game.
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
To build a program that could play chess, we have to specify:
The starting position of the chess board,
The rules that define legal moves, and
The board position that represent a win.
The starting position can be described by an 8 X 8 array square in which each element square (X, Y), (x
varying from 1 to 8 & y varying from 1 to 8) describes the board position of an appropriate piece in the
official chess opening position.
The goal is any board position in which the opponent does not have a legal move and his or her “king” is
under attack.
The legal moves provide the way of getting from initial state of final state.
The legal moves can be described as a set of rules consisting of two parts: A left side that gives the
current position and the right side that describes the change to be made to the board position.
An example is shown in the following figure.
Current Position: While pawn at square ( 5, 2 ), AND Square ( 5, 3 ) is empty, AND Square ( 5, 4 ) is
empty.
Changing Board Position: Move pawn from Square ( 5, 2 ) to Square ( 5, 4 ).
The current position of a chess coin on the board is its state and the set of all possible states is state
space.
One or more states where the problem terminates are goal states.
Chess has approximately 10¹²⁰ game paths. These positions comprise the problem search space.
Using above formulation, the problem of playing chess is defined as a problem of moving around in a
state space, where each state corresponds to a legal position of the board.
State space representation seems natural for playing chess problem because the set of states, which
Tiles Problem
This problem is also known as “Black and White Sliding Tiles Problem in Artificial
Intelligence “. There are 7 tiles, 3 are white and 3 are black and there is a white
space in the middle. All the black tiles are placed left and all the white tiles are
placed right.
Analyze the state-space of the problem. Propose a heuristic for this problem to move all the white tiles left to all the while tiles,
the position of the blank space is not important.
•
•
•
•
•
•
•
•
•
•
•
•
•
•
Initial State:
TILES: BBB WWW
Goal State:
TILES: WWW BBB
Assumptions
Heuristics for Black Tile = tile-distance to the first white tile to its right
Heuristics for White Tile = tile-distance to the first black tile to it's left * -1
We will run the script as long as we will have a non zero value for a tile.
If any black tile does not contain any white tile to its left then that tile will have Zero
Heuristics
If any white tile does not contain any black tile to its right then that tile will have Zero
Heuristics
We will have a selector value initially set as White.
For each iteration, we will change the value to black and white and so no.
Depending on the selector we will choose that colored tile with the highest tile says,
Tile X.
X will be moved to the blank space.
•
Algorithm
1. Selector:= white
2. Foreach black tile b
3. do h(b):= tile-distance to the first white tile to its right
4. Foreach white tile w
5. do h(w):= tile-distance to the first black tile to its left * -1
6. While any tile has a non-zero h value
7. Do
8. If selector:= white then,
9. Select the while-tile with the highest h value, say X
10.If the h(X):= 0 and it does not have the blank space to its left then,
11.Select another while-tile with the next-highest h value, say X
12.Selector := black
13.Else
14.Select the black-tile with the highest h value, say X
15.If the h(X):= 0 and it does not have the blank space to its left then,
16.Select another black-tile with the next-highest h value, say X
17.Selector:= white
18.If X and the blank space is in 2-tiles distance then,
19.Move X to the blank space and record the cost
20.Foreach black tile b
21.do h(b):= tile-distance to the first white tile to its right
22.Foreach white tile w
23.do h(w):= tile-distance to the first black tile to it's left * -1
24.End while