Showing papers on "Game tree published in 2013"

Reasoning about Strategies

Abstract: Samson Abramsky has placed landmarks in the world of logic and games that I have long admired. In this little piece, I discuss one theme in the overlap of our interests, namely, logical systems for reasoning with strategies - in gentle exploratory mode.

Towards a Snowdrift Game Optimization to Vertex Cover of Networks

Abstract: To solve the vertex cover problem in an agent-based and distributed networking systems utilizing local information, we treat each vertex as an intelligent rational agent rather than an inanimate one and provide a spatial-snowdrift-game-based optimization framework to vertex cover of networks. We analyze the inherent relation between the snowdrift game and the vertex cover: Strict Nash equilibriums of the spatial snowdrift game are the intermediate states between vertex-covered and minimal-vertex-covered states. Such equilibriums are obtained by employing the memory-based best response update rule. We also find that a better approximate solution in terms of the minimal vertex cover will be achieved by increasing the individuals' memory length, because such a process optimizes the individuals' strategies and helps them convert from bad equilibriums into better ones. Our findings pave a new way to solve the vertex cover problem from the perspective of agent-based self-organized optimization.

Enhancements to game components in gaming systems

Abstract: A computer-implemented method for enhancing game components in a gaming system, the method comprising: displaying at least one of a row and a column of the game components along a plane on a display device in accordance with a set of game rules for a given game, each one of the game components having an original symbol associated thereto; selecting at least one of the game components for enhancement; expanding selected ones of the game components outside of the plane and associating at least one additional symbol to expanded selected ones of the game components; and integrating the at least one additional symbol into the given game.

Monte-Carlo Fork Search for Cooperative Path-Finding

Abstract: This paper presents Monte-Carlo Fork Search (MCFS), a new algorithm that solves Cooperative Path-Finding (CPF) problems with simultaneity. The background is Monte-Carlo Tree Search (MCTS) and Nested Monte-Carlo Search (NMCS). Concerning CPF, MCFS avoids to enter into the curse of the very high branching factor. Regarding MCTS, the key idea of MCFS is to build a tree balanced over the whole game tree. To do so, after a simulation, MCFS stores the whole sequence of actions in the tree, which enables MCFS to fork new sequences at any depth in the built tree. This idea fits CPF problems in which the branching factor is too large for MCTS or A* approaches, and in which congestion may arise at any distance from the start state. With sufficient time and memory, Nested MCFS (NMCFS) solves congestion problems in the literature finding better solutions than the state-of-the-art solutions, and it solves N-puzzles without hole near-optimally. The algorithm is anytime and complete. The scalability of the approach is shown for gridsize up to \(200\times 200\) and up to \(400\) agents.

Investigating the Limits of Monte-Carlo Tree Search Methods in Computer Go

Abstract: Monte-Carlo Tree Search methods have led to huge progress in computer Go. Still, program performance is uneven - most current Go programs are much stronger in some aspects of the game, such as local fighting and positional evaluation, than in other aspects. Well known weaknesses of many programs include (1) the handling of several simultaneous fights, including the two safe groups problem, and (2) dealing with coexistence in seki.

Using double-oracle method and serialized alpha-beta search for pruning in simultaneous move games

Abstract: We focus on solving two-player zero-sum extensive-form games with perfect information and simultaneous moves. In these games, both players fully observe the current state of the game where they simultaneously make a move determining the next state of the game. We solve these games by a novel algorithm that relies on two components: (1) it iteratively solves the games that correspond to a single simultaneous move using a double-oracle method, and (2) it prunes the states of the game using bounds on the sub-game values obtained by the classical Alpha-Beta search on a serialized variant of the game. We experimentally evaluate our algorithm on the Goofspiel card game, a pursuit-evasion game, and randomly generated games. The results show that our novel algorithm typically provides significant running-time improvements and reduction in the number of evaluated nodes compared to the full search algorithm.

Improving Performance in Imperfect-Information Games with Large State and Action Spaces by Solving Endgames

Abstract: Sequential games of perfect information can be solved by backward induction, where solutions to endgames are propagated up the game tree. However, this does not work in imperfect-information games because different endgames can contain states that belong to the same information set and cannot be treated independently. In fact, we show that this approach can fail even in a simple game with a unique equilibrium and a single endgame. Nonetheless, we show that endgame solving can have significant benefits in imperfectinformation games with large state and action spaces: computation of exact (rather than approximate) equilibrium strategies, computation of relevant equilibrium refinements, significantly finer-grained action and information abstraction, new information abstraction algorithms that take into account the relevant distribution of players’ types entering the endgame, being able to select the coarseness of the action abstraction dynamically, additional abstraction techniques for speeding up endgame solving, a solution to the “off-tree” problem, and using different degrees of probability thresholding in modeling versus playing. We discuss each of these topics in detail, and introduce techniques that enable one to conduct endgame solving in a scalable way even when the number of states and actions in the game is large. Our experiments on two-player no-limit Texas Hold’em poker show that our approach leads to significant performance improvements in practice.

The game Grundy number of graphs

Abstract: Given a graph G=(V,E), two players, Alice and Bob, alternate their turns in choosing uncoloured vertices to be coloured. Whenever an uncoloured vertex is chosen, it is coloured by the least positive integer not used by any of its coloured neighbours. Alice’s goal is to minimise the total number of colours used in the game, and Bob’s goal is to maximise it. The game Grundy number of G is the number of colours used in the game when both players use optimal strategies. It is proved in this paper that the maximum game Grundy number of forests is 3, and the game Grundy number of any partial 2-tree is at most 7.

Sharing rewards in cooperative connectivity games

Abstract: We consider how selfish agents are likely to share revenues derived from maintaining connectivity between important network servers. We model a network where a failure of one node may disrupt communication between other nodes as a cooperative game called the vertex Connectivity Game (CG). In this game, each agent owns a vertex, and controls all the edges going to and from that vertex. A coalition of agents wins if it fully connects a certain subset of vertices in the graph, called the primary vertices. Power indices measure an agent's ability to affect the outcome of the game. We show that in our domain, such indices can be used to both determine the fair share of the revenues an agent is entitled to, and identify significant possible points of failure affecting the reliability of communication in the network. We show that in general graphs, calculating the Shapley and Banzhaf power indices is #P-complete, but suggest a polynomial algorithm for calculating them in trees. We also investigate finding stable payoff divisions of the revenues in CGs, captured by the game theoretic solution of the core, and its relaxations, the e-core and least core. We show a polynomial algorithm for computing the core of a CG, but show that testing whether an imputation is in thee-core is coNP-complete. Finally, we show that for trees, it is possible to test for e-core imputations in polynomial time.

Monte Carlo Tree Search for Simultaneous Move Games: A Case Study in the Game of Tron

Abstract: MCTS has been successfully applied to many sequential games. This paper investigates Monte Carlo Tree Search (MCTS) for the simultaneous move game Tron. In this paper we describe two different ways to model the simultaneous move game, as a standard sequential game and as a stacked matrix game. Several variants are presented to adapt MCTS to simultaneous move games, such as Sequential UCT, Decoupled UCT, Exp3, and a novel stochastic method based on Regret Matching. Through the experiments in the game of Tron on four different boards, it is shown that Decoupled UCB1-Tuned perform best, winning 62.3% of games overall. We also show that Regret Matching wins 53.1% of games overall and search techniques that model the game sequentially win 51.4-54.3% of games overall.

Method and apparatus for conducting a game of chance including a ticket

Abstract: A system and method are provided for playing a game of chance. The game of chance may include, for example, a lottery-type game. A result of the game of chance is revealed to a player in another medium. In one example, the result is revealed during multiple game instances of one or more online games. In one example, the online game includes a poker game, such as, for example, a pai gow poker game. In a version of this embodiment, the poker game provides for a player to arrange a plurality of cards dealt to the player into a first hand and a second hand. In another example, the poker game is coupled with a second level game in which the result is revealed. In a specific example, the second level game is a slot machine game.

Sufficiency-based selection strategy for MCTS

Abstract: Monte-Carlo Tree Search (MCTS) has proved a remarkably effective decision mechanism in many different game domains, including computer Go and general game playing (GGP). However, in GGP, where many disparate games are played, certain type of games have proved to be particularly problematic for MCTS. One of the problems are game trees with so-called optimistic moves, that is, bad moves that superficially look good but potentially require much simulation effort to prove otherwise. Such scenarios can be difficult to identify in real time and can lead to suboptimal or even harmful decisions. In this paper we investigate a selection strategy for MCTS to alleviate this problem. The strategy, called sufficiency threshold, concentrates simulation effort better for resolving potential optimistic move scenarios. The improved strategy is evaluated empirically in an n-arm-bandit test domain for highlighting its properties as well as in a state-of-the-art GGP agent to demonstrate its effectiveness in practice. The new strategy shows significant improvements in both domains.

Rminimax: An Optimally Randomized MINIMAX Algorithm

Abstract: This paper proposes a simple extension of the celebrated MINIMAX algorithm used in zero-sum two-player games, called Rminimax. The Rminimax algorithm allows controlling the strength of an artificial rival by randomizing its strategy in an optimal way. In particular, the randomized shortest-path framework is applied for biasing the artificial intelligence (AI) adversary toward worse or better solutions, therefore controlling its strength. In other words, our model aims at introducing/implementing bounded rationality to the MINIMAX algorithm. This framework takes into account all possible strategies by computing an optimal tradeoff between exploration (quantified by the entropy spread in the tree) and exploitation (quantified by the expected cost to an end game) of the game tree. As opposed to other tree-exploration techniques, this new algorithm considers complete paths of a tree (strategies) where a given entropy is spread. The optimal randomized strategy is efficiently computed by means of a simple recurrence relation while keeping the same complexity as the original MINIMAX. As a result, the Rminimax implements a nondeterministic strength-adapted AI opponent for board games in a principled way, thus avoiding the assumption of complete rationality. Simulations on two common games show that Rminimax behaves as expected.

On Applying Adaptive Data Structures to Multi-Player Game Playing

Abstract: In the field of game playing, the focus has been on two-player games, such as Chess and Go, rather than on multi-player games, with dominant multi-player techniques largely being an extension of two-player techniques to an \(N\)-player environment. To address the problem of multiple opponents, we propose the merging of two previously unrelated fields, namely those of multi-player game playing and Adaptive Data Structures (ADS). We present here a novel move-ordering heuristic for a dominant multi-player game playing algorithm, namely the Best-Reply Search (BRS). Our enhancement uses an ADS to rank the opponents in terms of their respective threat levels to the player modeled by the AI algorithm. This heuristic, referred to as Threat-ADS, has been rigorously tested, and the results conclusively demonstrate that, while it cannot damage the performance of BRS, it performs better in all cases examined.

Secondary Game to Symbol-Matrix Base Game

Abstract: The present invention is a gaming device having a secondary game played in conjunction with a symbol-matrix base game. The symbol-matrix game includes a special designation symbol within the symbol set associated with the base game. Occurrences of the special designation symbol in the symbol-matrix base game are spatially re-represented in a secondary matrix that is a mirrored representation of the symbol-matrix from the base game. Through a series of plays of the base game, the occurrences of the special designation symbol accumulate until a pre-determined pattern is established in the secondary matrix indicating a winning outcome of the secondary game.

Game providing device

Abstract: After a game has been started, game content drawing processing, game content placing processing, and point granting and character removing processing are repeatedly executed. Thus, the obtaining of a character by each player, the placement of the obtained character in an area, and the obtaining of points and the removal of the character from the area according to an elapsed time from the placement of the character in the area are repeatedly executed. When conditions to terminate the game hold, a result of the game is decided according to the number of points obtained by each player. Accordingly, more competitive game elements are realized in a game that uses multiple areas.

Decomposition techniques for Markov zero-sum games with nested information

Abstract: Markov zero-sum games arise in applications such as network interdiction, where an informed defender protects a network against attacks This problem has received significant attention in recent years due to its relevance to military problems and network security In this paper, we focus on finite games where the attacker knows imperfectly the network state, and formulate this as a Markov game with nested information By exploiting the nested information structure, we decompose the multistage game into a sequence of one-stage subgames and develop an algorithm that computes the value of the game and the saddle point strategies for the game This decomposition method computes the value of the game using backward induction as in stochastic dynamic programming, then identifies saddle-point strategies that achieve this value Using the Markov structure of the game, we show that the value of the game can be computed efficiently in terms of a single value function of an information state at each stage The resulting single stage optimization problems are much smaller than the original multistage game We illustrate our results with an example of multistage network interdiction where the attacker may not be able to observe outcomes of the attacks

A Game-Tree approach to discrete infinity Laplacian with running costs

Abstract: We give a self-contained and elementary proof for boundedness, existence, and uniqueness of solutions to dynamic programming principles (DPP) for biased tug-of-war games with running costs. The domain we work in is very general, and as a special case contains metric spaces. Technically, we introduce game-trees and show that a discretized flow converges uniformly, from which we obtain not only the existence, but also the uniqueness. Our arguments are entirely deterministic, and also do not rely on (semi-)continuity in any way; in particular, we do not need to mollify the DPP at the boundary for well-posedness.

Method and system for operating instances of a game

Abstract: Disclosed is a computer-implemented method of (and system for) operating instances of a game having a plurality of game positions that can be occupied by players, such as a poker-type game. The method comprises assigning a player a plurality of weights relating to game positions, where each weight indicates a bias towards placement of the player at a game position. When a player has played in a first game at a given position, the weights are updated to indicate an altered bias towards placement at each position. The player is then assigned to a second game based on the updated weights.

Synchronous and asynchronous game modes

Abstract: A system, machine-readable storage medium storing at least one program, and a computer-implemented method for switching between synchronous and asynchronous game modes is provided. A first game instance of a computer-implemented game of a first player and a second player is generated. The first game instance is generated in a first mode associated with the availability of the second player to play the game. First display data is provided to a client device of the first player to display the first game instance of the game in the first mode. A change in the availability of the second player is identified. A second game instance of the game is generated in a second mode associated with the change in the availability of the second player. Second display data is provided to the client device to display the second game instance of the game in the second mode.

Time-Shifted Multiplayer Game

Abstract: In one embodiment, a method provides a game for a first player. The method receives timing information for a second player that competed in a first instance of the game participated in by the second player and determines a set of parameters for an opponent in a second instance of the game based on the timing information. The second player started competing in the first instance of the game before the second instance of the game is started. Then, the opponent is created based on the set of parameters for the second instance of the game. After which, the method provides the second instance of the game in which the first player competes with the opponent. The opponent is automatically controlled in the second instance of the game by a game controller to perform according to the set of parameters.