Quantum Algorithms to Find Equilibrium in Sequential Games

GRD Journals | Global Research and Development Journal for Engineering | International Conference on Innovations in Engineering and Technology (ICIET) - 2016 | July 2016

e-ISSN: 2455-5703

Quantum Algorithms to Find Equilibrium in Sequential Games 1

Arish Pitchai 2A. V. Reddy 3Nickolas Savarimuthu 1,2,3 Department of Computer Applications 1,2,3 National Institute of Technology, Tiruchirappalli 620015, India Abstract Subgame Perfect Equilibrium (SGPE) is a special refinement of Nash equilibrium used in sequential games. A couple of quantum algorithms is presented in this paper to compute SGPE in a finite extensive form game with perfect information. The quantum search tools, Grover’s operator and Discrete quantum walk, are used to design the algorithms. A full-width game tree of average branching factor b and height h has n = O(bh) nodes in it. It will be shown in this paper that our algorithm uses O(n/(b1/2)) oracle queries to backtrack to the solution. The resultant speed-up is O(b1/2) times better than the best known classical approach, Zermelo's algorithm.

Keyword- Quantum algorithm, discrete quantum random walk, Quantum game theory, Algorithmic game theory, Sequential game, Nash Equilibrium, Subgame Perfect Equilibrium, Backward induction __________________________________________________________________________________________________

I. INTRODUCTION Game theory is concerned more with the study of strategic decision making scenarios than the simultaneous ones. The strategic game model, where sequential decisions made by each player are informed to all other players is called the extensive form game with perfect information. One of the most important solution concept defined by John Nash is the idea of Equilibrium [Osborne et al. (1994)]. To eliminate the threats that are not credible, Selten (1975) introduced subgame perfect equilibrium in extensive form games. Subgame perfectness is a refinement of Nash equilibrium based on the principle of sequential rationality. Our problem is to identify this strategy profile in a game tree (or extensive form game). This concept of sequential rationality is widely used in economics, psychology, computer science [Cigler et al. (2014)], biology, politics and more to solve complex problems.

Classically, the best way to solve this problem uses backward induction [Osborne et al. (1994)] which requires O(n) queries, where n is the number of nodes present in a game tree. In this paper, we present two quantum algorithms that detect perfect equilibrium with O(n/√b) queries, where b is the average branching factor. Our algorithms use Grover’s search operator and discrete quantum walk in combination with Zermelo’s backward induction method. Grover's search operator is used for searching an unsorted database with n elements in O(√n) time and using O(log n) storage space [Grover (1996)].

Discrete quantum walks have shown similar speed-up in search spaces such as hypercube, grids and more [Ambainis (2003)]. We take each smallest possible sub-tree of the game tree from the deepest level and quanta mechanically search for the node containing optimal value. Root of each sub-tree is updated with the search result and the same procedure is continued till the root of the game tree is reached. For simplicity, our quantum algorithms are assumed to be applied on a full-width game tree with uniform branching factor.

The paper is organized as follows. We begin section 2 with relevant definitions of game tree, Nash equilibrium and subgame perfect equilibrium. Reviewing the existing techniques to solve the problem is done in section 3. Preliminaries required for the better understanding of the algorithms are given in section 4. Detailed description of the quantum algorithms based on Grover's operator and discrete quantum walk to identify subgame perfect equilibrium and their results are provided in section 5.

In section 6, impact of quantum computation in solving the problem is discussed. We conclude this paper in section 7 with the limitations of our approach and open problems in quantum game theory.

II. PROBLEM DEFINITION The following are some basic definitions needed to understand the problem: 1) Definition 1: A finite extensive form game is given by a tuple T = ({X i}ih, q) where  h is the height of the game tree  Xi is the set of moves at level i  q: X1  …  Xh  ℝk is the outcome function, where k is the number of players.

All rights reserved by www.grdjournals.com

565

Quantum Algorithms to Find Equilibrium in Sequential Games (GRDJE / CONFERENCE / ICIET - 2016 / 091)

A play in the game is a tuple

x  ( x1 ,..., xh ) , where xi  Xi is the action selected at level Xi. For each play x , the k-tuple q( x )

describes the payoffs obtained by each of the k players in that run of the game.

s : X1  ...  X i 1  X i

2) Definition 2: A strategy for the player playing ith turn is a mapping i player should choose based on what has been played up to the point i – 1.

3) Definition 3: A strategy profile is a tuple of strategies (si)ih.

A strategy profile determines a play

x

as

xi  si ( x1 ,..., xi 1 )

and its corresponding outcome u

describing what move the

 q ( x ) . We write q: X1  … 

Xh  ℝ for the payoff of the jth player in q. Hence, given a play x , the payoff of player j is given by q j( x ). We also write

qi ( s1 ,..., sh )

for the jth player’s outcome, determined by the strategy profile (si)ih.

4) Definition 4 (Nash equilibrium). A strategy profile (si)ih is in Nash equilibrium if for each player j and alternative strategy

si* , we have

q j (s1 ,..., si ,..., sh )  q j ( s1 ,..., si* ,..., sh ) .

Informally, a strategy profile is in equilibrium if no player has an incentive to unilaterally change his strategy.

5) Definition 5: (Subgame). In any sequential game ({Xi}ih,q), a partial play

x1 ,..., xi 1

determines a subgame

Ti  ({ X p }i  p  h , q) with payoff function q j ( xi ,..., xh )  q j ( x1 ,..., xi 1 , xi ,..., xh ) for the completion of the play

( xi ,..., xh ) .

6) Definition 6 (Subgame perfect equilibrium). A strategy profile (s i)ih is in subgame perfect equilibrium if it is in Nash equilibrium on any subgame.

III. RELATED WORKS In this section we review related work on Subgame perfectness in extensive form games. A brute force computation requires examining every state in the normal (or the matrix form) representation of the game. It takes exponential time to compute the subgame perfect equilibrium because pruning the search space is possible only in extensive form. Since it suffers from combinatorial explosion, generalization of zermelo's algorithm [Zermelo (1913)] is preferred over brute force. It reduces the computational complexity of the problem.

Zermelo's algorithm is the predominant classical approach used to compute equilibrium in extensive form games of complete information [Osborne et al. (1994)]. It uses backward dynamic procedure to solve the problem. Selection of action xi  Xi, by player j, at each level i of the game is based on the highest utility value qj( x ) of possible actions, which is chosen from the lowest level of the tree to the highest. Mechanically, it is computed as follows. Consider any non-terminal node that comes just before terminal nodes, i.e., after each action branching from this node, the game terminates. Common sense of the player who moves at this node will make him choose the best move, the move that gives him the highest utility for himself. The sub-tree stemming from this node is deleted after assigning the payoff vector associated with current selection to the non-terminal node at hand, so that we have a shorter game, where the current non-terminal node is now a terminal node. This procedure is repeated until the root is reached. Number of queries required by this algorithm is proportional to the size of the game tree (O(n) = O(bh), where n is the number of nodes in the game tree, b is its average branching factor and h is its height).

Even though backward induction provides an algorithm very much better than the brute force approach, it isn't good enough for some games that require sequential decisions. For example, game tree of a reasonable chess game comes with average branching factor bavg = 35 and average game height havg = 80, backward induction needs 3580  10123 queries to identify the solution, which seems exponential in time. Game tree complexity of well-known strategy games like chess [Storer (1983)], stratego and havannah [Van den Herik et al. (2002)] exceeds the total number of atoms in the universe (1080). Recent work that addressed a similar problem in zero-sum games uses randomized techniques to bring the computational complexity down [Bopardikar et al. (2013)]. Game tree search space is reduced by guessing or sampling other player's moves and then the conventional approach is applied to obtain the solution. Even though application of random sampling, results in a computational complexity that is independent of the size of the game, probability of finding the solution depends mainly on the (random) selection of sub-matrices. Pioneering works on quantum games prove that quantum strategies are always at least as good as classical strategies [Meyer (1999), Eisert et al. (1999), Marinatto et al. (2000)]. Using quantum entanglement as a useful tool, backward induction is shown to generate equilibrium out of the quantum form of Stackelberg duopoly [Iqbal et al. (2002)].

Database search is a well-known example where quantum computation has shown quadratic speed up over the best available classical algorithms [Grover (2005)]. Discrete quantum walk, which is known to hit exponentially faster than classical random walk, is another remarkable search tool in the world of quantum algorithms. This special feature enables quantum walk to perform quantum search as good as Grover's approach in a variety of search spaces [Shenvi et al. (2003), Ambainis (2007)].

All rights reserved by www.grdjournals.com

566

Quantum Algorithms to Find Equilibrium in Sequential Games (GRDJE / CONFERENCE / ICIET - 2016 / 091)

Here, we amalgamate each of these tools with backward induction technique to devise two new quantum algorithms to solve subgame perfectness. The following section presents some useful background information that helps to understand the algorithms.

IV. PRELIMINARIES A. Grover’s Approach We start this sub-section by introducing a broadly applicable quantum search algorithm, the Grover’s algorithm, in terms of a quantum oracle [Nielsen et al. (2010)].

1) Quantum Oracle Let us assume that our aim is to search through a search space of N elements in an array A using their index in the range 0 to N – 1. For an oracle (or a Black box) to recognize the solution, the search problem is conveniently represented by a function f, which takes the index value of an array A as input. By definition, f(i) = 1 if A[i] is the solution to the search problem, and f(i) = 0 if it is not. This recognition is possible with the participation of an oracle qubit in the search process. More precisely, oracle, Uf, is a unitary operator acting on the computational basis: U f : i

 q  i  q  f (i ) , where i is the index register,  q is

the oracle qubit and  denotes the addition modulo two operator, which flips the oracle qubit if f(i) = 1, i.e., when the solution is identified.

In many quantum algorithms like Deutsch Jozsa [Deutsch et al. (1992)], the oracle qubit is initialized in the superposition state

0

 1  / 2 , which is very useful in the search process as shown here:  0 1 Uf : i   2 

  0 1   (1) f ( i ) i    2  

 .  

If A[i] is the solution (i.e., f(i) = 1), then the probability amplitudes of oracle qubit get interchanged and they remain unaltered if

i is not the solution. Action of oracle may be written as: U f : i  (1) f (i ) i .

Thus, a quantum oracle Uf, when appropriately exploited, marks the solution by shifting its phase. Application of oracle in the quantum search algorithm is elaborated in the following subsection.

2) Grover’s Operator Grover’s search algorithm is known to provide a polynomial time speed-up over the classical solutions. Grover's iterate is the backbone of this outstanding algorithm. This does the task of amplifying the probability amplitude of the target qubit  t arg et .

Grover operator G may be written as G =

(2  s  s  I )U f , where  s is the equally weighted superposition of states

and I is the identity operator.

Grover's operator actually performs the task of increasing the probability amplitude of the solution. Grover's search can be adopted substantially with an appropriate oracle function f to solve any kind of search problem. A subroutine, similar to the one proposed by Durr et al. (1996), is written to make the oracle U f identify the maximum among a set of elements.

B. Quantum Walk Approach Random walk, an essential tool for developing randomized algorithms, motivated the recent discovery of its quantum analogue, quantum walk. Quantum walks which are inherently counter-intuitive in behavior have exponentially faster hitting time than the classical random walks and do not converge in limiting distributions. Two well-known models of quantum walk classified based on the application of evolution operators are discrete-time quantum walk and continuous-time quantum walk. In this paper, a linear time quantum algorithm based on discrete quantum walk is presented.

1) Discrete Quantum Walk Model Our model, similar to that of the one used by Aaronson et al. (2003), is the quantum counterpart of classical random walk. The two basic components of this model are a Quantum walker and a Quantum coin. The walker moves in a Hilbert space (vertex space - Hv ) of infinite, but countable dimensions D. The outcomes of the coin flips, span the Hilbert space (coin space - Hc ) of arbitrary fixed dimension d. More specifically, a quantum walk is performed on a Hilbert space ℋ = system is represented as

Hc  Hv

and state of the

  coin, position , where coin  Hc and position  Hv .

All rights reserved by www.grdjournals.com

567

Quantum Algorithms to Find Equilibrium in Sequential Games (GRDJE / CONFERENCE / ICIET - 2016 / 091)

Evolution of a quantum system in ℋ is described by the unitary operator U = S.C. It is a two-step process: application of coin operator C followed by the application of shift operator S. Shift operator is a unitary transformation defined on such that

S a, u  a, v where v is the ath neighbor of u. Coin operator is a unitary transformation on Hc . This walk is

executed t times on an undirected graph G (V, E).

Here,



Hc  Hv

initial

 coin, position

initial



final

 (U )t 

initial

is the representation of a discrete quantum walk.

and t is the number of applications of U. Our aim is to identify the marked vertex

vt arg et Hv . Success of the algorithm depends on the probability of measuring position state to observe the vertex vt arg et as the result.

2) Quantum Walk Search The following are some definitions given for the better understanding of the quantum walk based algorithm given in Algorithm 2.

7) Definition 7: Hypercube is a regular graph of degree d with D = 2 d vertices. Each vertex is labeled by a d-bit binary string.

Two nodes u and v in a hypercube are adjacent if and only if they differ by a single bit flip, i.e., their hamming distance is one.

Our algorithm based on discrete quantum walk transforms a subtree into a hypercube search space to gain speed-up in the search process. For simplicity, the average branching factor b is assumed to be a power of two. So, the Hilbert space associated with our quantum walk is H operator C and coin C0.

H2

 Hd H2

d

, where H

d

is the d dimensional Hilbert space associated with the coin

d

is the vertex space. Most frequently used coin operator for discrete quantum walk search is the Grover's

C0  2  s  s  I d

8) Definition 8. Grover's coin is defined as canonical basis, where

s

1  d

on the d-dimensional Hilbert space H

d

with

i

as its

d 1

i

and Id is the unit matrix of order d.

i 0

The Shift operator S moves the walker from its state a v

to a v  ea , where

ea is a d-bit binary string with

zeroes at all positions except ath bit and  is the bit-wise XOR operator. It can be represented as S : a v  a v  ea .

Since, the coin is symmetric in all d directions equally, a perturbation is introduced in the coin operator for marked vertices.

9) Definition 9. Perturbed walk U' = S. C' is a unitary transformation with oracular coin C1 = –Id for the marked vertex and



Grover's coin C0 for the unmarked vertices, where C '  C0  I d  vt arg et Inhomogeneity in the perturbed walk makes it capable of identifying



vt arg et  C1  vt arg et

vt arg et

vt arg et at the end of algorithm.

V. ALGORITHM AND RESULTS We start with an informal description of our approaches to solve the problem. For simplicity, we assume the game tree T is a full-width tree with height h and average branching factor b. Let n=O(bh) be the number of nodes present in the game tree T. Finding subgame perfect equilibrium (SGPE) in T is reduced to player j selecting an action xi  Xi (among leaf nodes branching from an sub-tree Ti) that results in maximum utility value qj. Then the selected utility value is assigned to the root of Ti while pruning its leaf nodes. This process starts from the rightmost sub-tree at the deepest level h and is continued till the root of T is reached.

On a classical probabilistic Turing machine, linear number of queries are needed to find the maximum value in an array of elements. Our quantum mechanical tools makes it possible with O(√b) queries to search an array of length b. Both Grover's operator and discrete quantum walks are being used in the design of our algorithms to get the maximum utility value from each sub-tree Ti. Then, they are nested backward to reach the top of the game tree.

A. Algorithm 1: Grover’s operator based SGPE algorithm As mentioned in section 4, Grover's iteration is capable of increasing probability amplitude of the index holding the solution.

Algorithm 1 Compute SGPE using Grover's operator Input A game tree T of average branching factor b and height h.

All rights reserved by www.grdjournals.com

568

Quantum Algorithms to Find Equilibrium in Sequential Games (GRDJE / CONFERENCE / ICIET - 2016 / 091)

Output A leaf node of tree T such that it is the subgame perfect equilibrium of T. 1: procedure 2: for each farthest sub-tree node Ti  T do 3: index leaf nodes of Ti with numbers from 0 to b-1 4: choose threshold index 0 < y < b-1 uniformly at random 5: while running time<(22.5√b+1.4log2b) do 6:

initialize the memory as

 j

1 j y b

7: 8: 9:

mark every item j for which Ti[j] > Ti[y] apply Grover's search observe the first register: let y' be the outcome 10: if Ti[y'] > Ti[y] then 11: set threshold index y to y' 12: end if 13: end while 14: replace utility value of root(Ti) with the utility value of y 15: end for 16: return T 17: end procedure An efficient oracular function to find the node with maximum utility of a player is implemented here. An index y is chosen at random and oracle Uf marks the values that are greater than the value y holds. Index of one of the marked elements, amplified by Grover's operator, replaces y. This process continues for O(√b) times as explained in the pseudocode of Algorithm 1. The result of Algorithm 1 is given below.

1) Theorem 1. There exists a Grover's operator based quantum algorithm to compute subgame perfect equilibrium in a game tree of average branching factor b and height h with O(n/√b) queries.  Proof. Result of the work of Durr et al. (1996) proves that the while loop at step 5 of Algorithm 1 finds the index y holding maximum utility value with probability at least 1/2 in t g=22.5√b+ 1.4log2b iterations.

Thus, maximum utility value of a player at each sub-tree TiT is found with the Grover's operator in O(√b).

Number of queries Qn required to identify SGPE is Qn = tg  tloop, where tloop is the number of times the for loop at step 2 of Algorithm 1 iterates the while loop at step 5.

First iteration starts from the level h-1 (the level that contains the farthest sub-tree).

After the sub-trees at level h-1 are traversed, the height of the tree gets becomes h-1, because the leaf nodes under each sub-tree at height h-1 are deleted (by step 14). This pruning process gets repeated till the root node of T (where h = 0) is reached.

Thus, tloop is the total number of smallest possible sub-trees (or internal nodes) present in a game tree.

At any level l, number of nodes present is b l.

Therefore, tloop  b h 1  b h  2  ...  b 0 

h 1

b

i

i 0

h It is a geometric progression with common ratio b and one as a scale factor. Thus, the sum is given by tloop  b  1 . b 1

 bh  1  2  22.5 b  1.4 log b .  b 1 

Hence, Qn  





Here, (bh – 1)  n and (b - 1)  b for large values of b.

Thus, Qn = O(n/√b) Hence, it is proved that the proposed algorithm based on Grover's search operator is capable of computing subgame perfect equilibrium in a game tree with O(n/√b) queries.

B. Algorithm 2: Discrete Quantum Walk based SGPE algorithm Algorithm 2 Compute SGPE using Quantum walk Input A game tree T of average branching factor b and height h.

All rights reserved by www.grdjournals.com

569

Quantum Algorithms to Find Equilibrium in Sequential Games (GRDJE / CONFERENCE / ICIET - 2016 / 091)

Output A leaf node of tree T such that it is the subgame perfect equilibrium of T. 1: procedure 2: label all leaf nodes with alphabets

l1 , l2, ,..., lbh 3: for each farthest sub-tree node Ti  T do 4: index leaf nodes of Ti with numbers with d-bit binary strings 5: generate uniform superposition:

1 d 1 D 1  i  j dD i 0 j 0 c

0 c 0 s 6:

choose

S   d , x  ed

s

d, x

d ,x

7:

as the propagator use the perturbed coin C’ and perform

tf  8:



2d steps of the walk U’

2

measure the final state in d , x basis

9:

replace sub-tree Ti by the root of Ti updated with the label and pay-off of the measured solution 10: end for 11: return T 12: end procedure Discrete quantum walk, as previously mentioned in section 4, is known to hit exponentially faster than its classical counterpart.

This peculiar property of quantum walk makes it possible to search faster in a variety of search spaces. The construction of our algorithm starts by structurally transforming the sub-tree Ti into a hypercube. The maximum utility value for player j is then picked with the help of a perturbed discrete quantum walk in O(√b) steps. The same walk is then applied towards the top of the game tree T as described in pseudocode of Algorithm 2.

The result of Algorithm 2 is given below.

2) Theorem 2. There exists a quantum walk algorithm to compute subgame perfect equilibrium in a game tree of average branching factor b and height h with O(n/√b) queries. 

Proof. We start our proof using the result of the work of Shenvi et al. (2003). They proved that t w  quantum

walk



U'

=

S.C'

C '  C0  I d  vt arg et vt arg et

with

the

 C  v 1

t arg et

propagator

S   d , x  ed

d, x

and

the



2

2d steps of the perturbed

coin

d ,x

vt arg et on a hypercube of dimension d results in the measurement of

marked state with probability ½ – O(1/d).

Conversion of leaf nodes li of each subtree Ti into hypercube search space enables faster search for the maximum utility value in the sub-tree. By this conversion, each sub-tree needs

 b 2

queries (by step 7 of Algorithm 2) to get equilibrium, as

the smallest sub-tree is assumed to contain b = 2d leaf nodes in it.

Number of queries Qn required to identify SGPE is Qn = tw  tloop, where tloop is the number of times for loop at step 3 of Algorithm 2 executes.

The loop starts from the farthest internal node which is at level h-1.

At the end of the quantum walks in sub-trees at a level, height of the game tree gets reduced by one i.e., h-1, because the leaf nodes under each sub-tree at height h-1 are deleted (by step 9) after the O(√b) step walks. Then, this level order execution of quantum walks is performed in level h-2. This process is repeated until the root node of T (where h = 0) is reached.

Thus, tloop is the total number of smallest possible sub-trees (or internal nodes) present in a game tree.

tloop 

bh  1 (Refer proof of Theorem 1). b 1 All rights reserved by www.grdjournals.com

570

Quantum Algorithms to Find Equilibrium in Sequential Games (GRDJE / CONFERENCE / ICIET - 2016 / 091)

 bh  1     b.    b 1   2

Hence, Qn  

Here, (bh – 1)  n and (b - 1)  b for large values of b.

Thus, Qn = O(n/√b).

Hence, it is proved that the proposed algorithm based on discrete quantum walk is capable of computing subgame perfect equilibrium in a game tree with O(n/√b) queries.

The results of our algorithms show that quantum computation is capable of extending significant improvement in running time of finding subgame perfect equilibrium in sequential games.

VI. DISCUSSION In this work, we consider the impact of incorporating quantum computational tools alongside backward induction in finding equilibrium in sequential games. The problem shows an exponential growth in the number of leaf nodes to be examined with the increment in height. Query complexity associated, a function of the branching factor b and the height h, is of the form O(b h). The above results show that the performance of our algorithms is O(√b) times faster than the best existing algorithm. It is easier to precede the discussion by examining Table 1, which compares the classical and quantum complexities of some famous games.

Branching factor Height O(n) O(n/√b) (b) (h) (power of 10) (power of 10) Connect6 46000 30 140 137 Arimaa 17281 92 390 388 Amazons 374 84 216 214 Hex 280 40 98 96 Go 250 150 360 359 Chess 35 80 123 122 Table 1: Comparison of query complexity in sequential games Game

As it turns out, the application of Grover's operator and discrete-time quantum walk with backward induction is responsible for the speedup in our approaches. The application of G with an efficient oracular function to identify the maximum utility value speeds up the search process in Algorithm 1. The perturbed walk with Grover's coin C 0 for the marked state accelerates the search in each sub-tree in Algorithm 2 and backward induction procedure preserves correctness of the solution.

The probability of picking up the solution at each sub-tree  1/2 for both the algorithms, a constant repetition of the quantum techniques enhances the probability to nearly one [Shenvi et al. (2003)]. Recent refinements proposed to the Grover's search [Grover (2005)] and quantum walk search [Potoček et al. (2009)] reduces the running time complexity. Throughout the paper, it assumed that the game tree we are searching has a unique equilibrium node, which is a rare possibility. Analyzing the effect of quantum approaches in the presence of multiple solutions is taken for future enhancement of the algorithm.

VII.

CONCLUSION

We addressed the problem of finding subgame perfectness in sequential games using two popular quantum search tools. We have shown that our algorithm computes the solution in a sequential game with O(n/√b) queries. We provide a new perspective on designing quantum algorithms for classical games. This work opens up a number of future directions of research. Some of the research challenges include identifying solutions if they exist in multiple numbers, improving probability of measuring the solution and achieving exponential speedup over the classical algorithms.

ACKNOWLEDGEMENTS The authors wish to thank Hemalatha Thiagarajan and Michael Arock who provided insight and expertise that greatly assisted the research.

REFERENCES [1] Aaronson, S., & Ambainis, A. (2003, October). Quantum search of spatial regions. In Foundations of Computer Science, 2003. Proceedings. 44th Annual IEEE Symposium on (pp. 200-209). IEEE. [2] Ambainis, A. (2003). Quantum walks and their algorithmic applications.International Journal of Quantum Information, 1(04), 507-518.

[3] Ambainis, A. (2007). Quantum walk algorithm for element distinctness.SIAM Journal on Computing, 37(1), 210-239.

[4] Bopardikar, S. D., Borri, A., Hespanha, J. P., Prandini, M., & Di Benedetto, M. D. (2013). Randomized sampling for large zero-sum games. Automatica,49(5), 1184-1194.

All rights reserved by www.grdjournals.com

571

Quantum Algorithms to Find Equilibrium in Sequential Games (GRDJE / CONFERENCE / ICIET - 2016 / 091)

[5] Cigler, L., & Faltings, B. (2014). Symmetric subgame-perfect equilibria in resource allocation. Journal of Artificial Intelligence Research, 323-361.

[6] Deutsch, D., & Jozsa, R. (1992, December). Rapid solution of problems by quantum computation. In Proceedings of the Royal Society of London A: Mathematical, Physical and Engineering Sciences (Vol. 439, No. 1907, pp. 553-558). The Royal Society.

[7] Durr, C., & Hoyer, P. (1996). A quantum algorithm for finding the minimum.arXiv preprint quant-ph/9607014.

[8] Eisert, J., Wilkens, M., & Lewenstein, M. (1999). Quantum games and quantum strategies. Physical Review Letters, 83(15), 3077.

[9] Grover, L. K. (1996, July). A fast quantum mechanical algorithm for database search. In Proceedings of the twenty-eighth annual ACM symposium on Theory of computing (pp. 212-219). ACM. [10] Grover, L. K. (2005). Quantum Search Algorithm can be Improved.International Journal of Quantum Information, 3(01), 23-30.

[11] Iqbal, A., & Toor, A. H. (2002). Backwards-induction outcome in a quantum game. Physical Review A, 65(5), 052328.

[12] Marinatto, L., & Weber, T. (2000). A quantum approach to static games of complete information. Physics Letters A, 272(5), 291-303.

[13] Meyer, D. A. (1999). Quantum strategies. Physical Review Letters, 82(5), 1052.

[14] Nielsen, M. A., & Chuang, I. L. (2010). Quantum computation and quantum information. Cambridge university press.

[15] Osborne, M. J., & Rubinstein, A. (1994). A course in game theory. MIT press.

[16] Potoček, V., Gábris, A., Kiss, T., & Jex, I. (2009). Optimized quantum random-walk search algorithms on the hypercube. Physical Review A, 79(1), 012325.

[17] Selten, R. (1975). Reexamination of the perfectness concept for equilibrium points in extensive games. International journal of game theory, 4(1), 25-55.

[18] Shenvi, N., Kempe, J., & Whaley, K. B. (2003). Quantum random-walk search algorithm. Physical Review A, 67(5), 052307.

[19] Storer, J. A. (1983). On the complexity of chess. Journal of Computer and System Sciences, 27(1), 77-100.

[20] Van den Herik, H. J., Uiterwijk, J. W., & Van Rijswijck, J. (2002). Games solved: Now and in the future. Artificial Intelligence, 134(1), 277-311.

[21] Zermelo, E. (1913). Über eine Anwendung der Mengenlehre auf die Theorie des Schachspiels. In Proceedings of the fifth international congress of mathematicians (Vol. 2, pp. 501-504). II, Cambridge UP, Cambridge.

All rights reserved by www.grdjournals.com

572