DeepAI
Log In Sign Up

Adaptive Relaxations for Multistage Robust Optimization

06/24/2021
by   Michael Hartisch, et al.
University of Siegen
0

Multistage robust optimization problems can be interpreted as two-person zero-sum games between two players. We exploit this game-like nature and utilize a game tree search in order to solve quantified integer programs (QIPs). In this algorithmic environment relaxations are repeatedly called to asses the quality of a branching variable and for the generation of bounds. A useful relaxation, however, must be well balanced with regard to its quality and its computing time. We present two relaxations that incorporate scenarios from the uncertainty set, whereby the considered set of scenarios is continuously adapted according to the latest information gathered during the search process. Using selection, assignment, and runway scheduling problems as a testbed, we show the impact of our findings.

READ FULL TEXT VIEW PDF

page 1

page 2

page 3

page 4

11/29/2018

Game Tree Search in a Robust Multistage Optimization Framework: Exploiting Pruning Mechanisms

We investigate pruning in search trees of so-called quantified integer l...
10/20/2022

A general model-and-run solver for multistage robust discrete linear optimization

The necessity to deal with uncertain data is a major challenge in decisi...
11/22/2020

Play Like the Pros? Solving the Game of Darts as a Dynamic Zero-Sum Game

The game of darts has enjoyed great growth over the past decade with the...
02/11/2021

Common Information Belief based Dynamic Programs for Stochastic Zero-sum Games with Competing Teams

Decentralized team problems where players have asymmetric information ab...
12/23/2022

Adapting to game trees in zero-sum imperfect information games

Imperfect information games (IIG) are games in which each player only pa...
07/30/2019

Open shop scheduling games

This paper takes a game theoretical approach to open shop scheduling pro...
07/24/2022

A Parallel Novelty Search Metaheuristic Applied to a Wildfire Prediction System

Wildfires are a highly prevalent multi-causal environmental phenomenon. ...

1 Introduction

Most aspects of decision making are highly affected by uncertainty. In order to take such uncertainty into account different methodologies have been developed, such as stochastic programming [25] or robust optimization [4]. In this setting, multistage models can be used to obtain an even more realistic description of the underlying problem. While there are several real multistage stochastic approaches (e.g. [30, 23]), extensions to robust optimization with more than two stages only recently gained more attention (e.g. [11, 5]). Due to their PSPACE-complete nature [32], tackling multistage robust problems is a very complicated task and for the human mind even comprehending a solution is rather challenging. Solution approaches include approximation techniques [6], dynamic programming [36], and solving the deterministic equivalent problem (DEP), also referred to as robust counterpart [4], often using decomposition techniques (e.g. [38]). We, on the other hand, exploit the similarity of multistage robust problems with two-person zero-sum games and apply a game tree search to solve quantified integer programs (QIPs) [37, 14]

. QIPs are integer linear programs with ordered variables that are either existentially or universally quantified, and provide a convenient framework for multistage robust optimization, allowing polyhedral or even decision-dependent uncertainty sets

[21]. The very intuitive approach of applying game tree search to solve the very compact QIP formulation paves the way for large multistage problems: a recent computational study showed that solving robust discrete problems with multiple stages is well within the reach of current computational prowess [17].

As in any tree search algorithm, a rapid but high-quality assessment of the potential of different subtrees is crucial for the search process. This can be done by relaxing some problem conditions in order to obtain a bound on the optimal value of a (sub)problem. In mixed integer linear programming (MIP), variants of the linear programming (LP)-relaxation of a problem are employed [3]. Equivalently for QIPs, the quantified linear programming (QLP)-relaxation can be used. But its DEP’s size remains exponentially large, even when tackled with decomposition techniques [28]. By further relaxing the variables’ quantification the LP-relaxation of a QIP arises, which, however, completely neglects the problem’s multistage and uncertain nature. In order to restore the robust nature of the problem, we exploit that a solution must cope with any uncertain scenario: fixing (originally) universally quantified variables in this LP-relaxation yields a very powerful tool in our tree search algorithm. Furthermore, we show that if only a small subset of the uncertainty set is considered in the QLP-relaxation, the correseponding DEP remains small enough to yield an effective relaxation. This local approximation, which has similarites to sampling techniques [18], is utilized to eventually obtain the optimal solution for a multistage robust optimization problem.

For both enhanced relaxations the selection of incorporated scenarios crucially affects their effectiveness, i.e. having reasonable knowledge of which universal variable assignments are particularly vicious can massively boost the search process. We partially rely on existing heuristics, developed to analyze and find such promising assignments in a game tree search environment

[2, 35] as well as for solving SAT problems [31]. As these heuristic evaluations change over time, the relaxations adapt based on newly gathered information.

In Section 2 we introduce the basics of quantified programming and outline the used game tree search. In Section 3 we present the utilized relaxations and we illustrate the strength of our approach in a computational study in Section 4, before we conclude in Section 5.

2 Quantified Programming

In the following, we formally introduce quantified integer programming. [19] can be consulted for a more detailed discussion.

2.1 Basics of Quantified Integer Programming

A QIP can be interpreted as a two-person zero-sum game between an existential player setting the existentially quantified variables and a universal player setting the universally quantified variables. The variables are set in consecutive order according to the variable sequence . For each variable its domain is given by

and the domain of the entire variable vector is

. In the following, vectors are always written in bold font and the transpose sign for the scalar product between vectors is dropped for ease of notation. Let denote the vector of quantifiers. We call each maximal consecutive subsequence in consisting of identical quantifiers a block. The quantifier corresponding to the -th quantifier block is given by . Let denote the number of variable blocks. With we denote the corresponding domain of the -th variable block as in . At each move , the corresponding player knows the settings of before taking her decision. Each fixed vector , that is, when the existential player has fixed the existential variables and the universal player has fixed the universal variables, is called a play. If satisfies the existential constraint system , the existential player pays to the universal player. If does not satisfy , we say the existential player loses and the payoff is . Therefore, it is the existential player’s primary goal to ensure the fulfillment of the constraint system, while the universal player tries to violate some constraints. If the existential player is able to ensure that all constraints are fulfilled he tries to minimize , whereas the universal player tries to maximize her payoff.

We consider QIPs with polyhedral uncertainty [20, 19] and therefore a universal constraint system is introduced, with , i.e. the submatrix of corresponding to existentially quantified variables is zero. Here the main goal of the universal player becomes satisfying this universal constraint system and therefore the universally quantified variables are restricted to a polytope. In particular, a universal variable assignment must not make it impossible to satisfy the system . Wit the system restricts universal variables in such way that their range only depends on previous universal variables (cf. [21]).

Definition 1 (QIP with Polyhedral Uncertainty)

Let and be given with . Let be the vector of objective coefficients, for which denotes the vector of coefficients belonging to block . The term with the component-wise binding operator denotes the quantification sequence such that every quantifier binds the variables of block ranging in their domain , with

We call

a QIP with polyhedral uncertainty given by the tuple .

We use to describe the domain of the existentially quantified variables, given by their variables bounds as in . is the domain of universally quantified variables, i.e. the uncertainty set, given by their domain and the universal constraint system. and denote the vectors only containing the existentially and universally quantified variables of game , respectively. We call a scenario and refer to a partially filled universal variable vector as a subscenario. Additionally, we use to describe the domain given by without the integrality condition.

2.2 Solving QIP via Game Tree Search

A game tree can be used to represent the chronological order of all possible moves, given by the quantification sequence . The nodes in the game tree represent a partially assigned variable vector and branches correspond to assignments of variables according to their variable domain. A solution of a QIP is a so-called winning (existential) strategy, that defines how to react to each legal move by the universal player, in order to ensure . Hence, a solution is a subtree of the game tree with an exponential number of leaves with respect to the number of universal variables. If no such strategy exists the QIP is infeasible. If there is more than one solution, the objective function aims for a certain (the “best”) one, whereat the value of a strategy is defined via the worst-case payoff at its leaves (see Stockman’s Theorem [34]). The play resulting in this leaf is called the principal variation [8], which is the sequence of variable assignments being chosen during optimal play by both players.

The heart of the used search-based solver for 0/1-QIPs [13] is an arithmetic linear constraint database together with an alpha-beta algorithm, which has been successfully used in gaming programs, e.g. chess programs for many years [26, 12]. The solver proceeds in two phases in order to find an optimal solution:

  • feasibility phase: It is checked whether the instance has any solution. The solver acts like a quantified boolean formula (QBF) solver [7, 27] with some extra abilities. Technically it performs a null window search [33].

  • optimization phase: The solution space is explored via alpha-beta algorithm in order to find the provable optimal solution.

The alpha-beta algorithm is enhanced by non-chronological backtracking and backward implication [15, 10]: when a contradiction is detected a reason in form of a clause is added to the constraint database and the search returns to the node where the found contradiction is no longer imminent. The solver deals with constraint learning on the so-called primal side as known from SAT- and QBF-solving (e.g. [29, 16]), as well as with constraint learning on the dual side known from MIP (e.g. [9]). Several other techniques are implemented, e.g. restart strategies [24], branching heuristics [1], and pruning mechanisms [22]. Furthermore, relaxations are heavily used during the optimization phase: at every search node a relaxation is called in order to asses the quality of a branching decision, the satisfiability of the existential constraint system or for the generation of bounds.

3 Enhanced Relaxations

3.1 Relaxations for QIPs

In case of a quantified program, besides relaxing the integrality of variables, the quantification sequence can be altered by changing the order or quantification of the variables. An LP-relaxation of a QIP can be built by dropping the integrality and also dropping universal quantification, i.e. each variable is considered to be an existential variable with continuous domain. One major drawback of this LP-relaxation is that the worst-case perspective is lost by freeing the constraint system from having to be satisfied for any assignment of the universally quantified variables: transferring the responsibility of universal variables to the existential player and solving the single-player game has nothing to do with the worst-case outcome in most cases. In order to strengthen this relaxation we use that for any assignment of the universally quantified variables the constraint system must be fulfilled. Hence, fixing universally quantified variables according to some element of still yields a valid relaxation. This can be interpreted as knowing the opponent moves beforehand and adapting one’s own moves for this special play.

Definition 2 (LP-Relaxation with Fixed Scenario)

Let and let be a fixed scenario. The LP

is called the LP-relaxation with fixed scenario of .

Proposition 3

Let and let be the corresponding LP-relaxation with fixed scenario . Then the following holds:

  • If is infeasible, then also is infeasible.

  • If is feasible with optimal value , then either is infeasible or is feasible with optimal value , i.e. constitutes a lower bound.

Proof
  • If is infeasible then

    and since there cannot exist a winning strategy for . As a gaming argument we can interpret this the following way: If there is some move sequence of the opponent we cannot react to in a victorious way—even if we know the sequence beforehand—the game is lost for sure.

  • Let be the optimal value of , and let be the corresponding fixation of the existential variables. It is

    (1)

    If is feasible, scenario must also be present in the corresponding winning strategy. Let be the corresponding play, i.e. . With Equation (1) obviously and thus with Stockman’s Theorem [34] .

As we will show in Section 4 adding a scenario to the LP-relaxation already massively speeds up the search process compared to the use of the standard LP-relaxation. However, partially incorporating the multistage nature into a relaxation should yield even better bounds. Therefore, we reintroduce the original order of the variables while only taking a subset of scenarios into account.

Definition 4 (-Relaxation)

Given . Let and let . We call

(2)

the -relaxation of .

Proposition 5

Let be feasible and let be the -relaxation with and optimal value . Then is a lower bound on the optimal value of , i.e. .

Proof

Again we use a gaming argument: with the universal player is restricted to a subset of her moves in problem , while the existential player is no longer restricted to use integer values. Furthermore, any strategy for can be mapped to a strategy for the restricted game . Hence, the optimal strategy for is either part of a strategy for or it is an even better strategy, as the existential player does not have to cope with the entire variety of the universal player’s moves. Therefore, .

In general, has exponential size with respect to the number of universally quantified variables. Therefore, the main idea is to keep a rather small subset of . This way the DEP of the -relaxation—which is a standard LP— remains easy to handle for standard LP solvers.

Example 6

Consider the following binary QIP (The min/max alternation in the objective is omitted for clarity):

The optimal first-stage solution is , the principal variation is and hence the optimal value is . Let be a set of scenarios. The two LP-relaxations with fixed scenario accoring to the two scenarios in are shown in Table 1.

scenario , ,
relaxation
solution , ,
objective -2 -2
Table 1: Solutions of the single LP-relaxations with fixed scenarios.

Both yield the optimal first stage solution of setting to one. Now consider the DEP of the -relaxation in which represents the assignment of after is set to :

In the -relaxation it is ensured that variables following equal sub-scenarios are set to the same value. As is set to in each considered scenario in , must be set to the same value in both cases. The solution of the DEP is , and . Thus, the -relaxation yields the lower bound -1 for the original QIP. This is not only a better bound than the one obtained by the two LP-relaxations with individually fixed scenarios but it is also a tight bound.

3.2 Scenario Selection

Both for the LP-relaxation with fixed scenario as well as the -relaxation the selection of scenarios is crucial. For the -relaxation additionally the size of the scenario set affects its performance, in particular if too many scenarios are chosen, solving the relaxation might consume too much time. We use three heuristics to collect information on universal variables during the search:

VSIDS heuristic [31].

Each variable in each polarity has a counter, initialized to 0. When a clause is added, due to a found conflict, the counter associated with each literal is incremented. Periodically, all counters are divided by a constant.

Killer heuristic [2].

When a conflict is found during the search the current assignment of universal variables—and thus the (sub)scenario leading to this conflict—is stored in the vector. This is a short-term information and is overwritten as soon as a new conflict is found.

Scenario frequency.

For each scenario and subscenario the frequency of their occurrence during the search is stored.

The LP-relaxation with fixed scenario is implemented as follows: before calling the LP solver in a decision node, all variable bounds must be updated according to the current node anyway. When doing so (yet unassigned) universally quantified variables are set as in Algorithm 1. Hence, the considered scenario is adapted in every decision node based on the latest heuristic information.

1:for each universal variable block  do
2:     for each unassigned variable in block , in random order  do
3:         if   then
4:         else          
5:         if  setting to is legal according to  then
6:         else                
Algorithm 1 Building a scenario

The -relaxation is adapted at each restart. The scenario set is rebuilt by considering the most frequently used (sub)scenarios. Subscenarios are extended to a full scenario according to Algorithm 1. Even though starting with (sub)scenarios, often contains fewer unique scenarios, as extending a subscenario may result in a scenario already contained in .

Furthermore, our implementation merges the LP-relaxation with fixed scenario into the -relaxation: the final relaxation takes all scenarios in the scenario set , as well as one additional scenario that can be updated at each decision node into account. Hence, the used relaxation in fact reflects scenarios and in case of the LP-relaxation with fixed scenario remains. The DEP of this final relaxation is built and solved with an external LP solver.

The -relaxation is currently only used while the search is in the very first variable block, i.e. as soon as all variables of the first block are assigned, only the LP-relaxation with fixed scenario is used. The reason why this relaxation is no longer used in later variable blocks is that then universally quantified variables are already fixed according to the current search node. Hence, some scenarios in are no longer relevant as they refer to other parts of the search tree. Therefore, in order to use the -relaxation in higher blocks it needs to be rebuilt each time a universal variable block is bypassed.

4 Experiments

4.1 Problem Descriptions

We conduct experiments on three different QIPs with polyhedral uncertainty. For a more detailed discussion on the problem formulations we refer to [19].

Multistage robust selection.

The goal is to select out of items with minimal costs. In an initial (existential) decision stage a set of items can be selected for fixed costs. Then, in a universal decision stage, one of cost scenario is disclosed. In the subsequent existential decision stage further items can be selected for the revealed costs. The latter two stages are repeated iteratively times. Hence, there are variable blocks.

Multistage robust assignment.

The goal is to find a perfect matching for a bipartite graph , , , with minimal costs. In an initial (existential) decision stage a set of edges can be selected for fixed costs. Then, in a universal decision stage, one of cost scenario is disclosed. In the subsequent existential decision stage further edges can be selected for the revealed costs. Those two stages are repeated iteratively times. Both for the selection and the assignment problem, a universal constraint system is used to force the universally quantified variables to reveal exactly one scenario per period.

Multistage robust runway scheduling.

Each airplane has to be assigned to exactly one time slot and at most airplanes can be assigned to one time slot (as there are only runways). As soon as the (uncertain) time window in which the airplane can land is disclosed by universally quantified variables, the initial plan has to be adapted. The goal is to find an initial schedule that can be adapted according to the later disclosed time windows with optimal worst-case costs, as for each slot that the airplane is moved away from its originally planned time slot, a cost is incurred. The time window disclosure occurs in periods: the airplanes are partitioned into groups and after the initial schedule is fixed the time windows are disclosed for one group after the other. After each disclosure the schedule for the current group of airplanes has to be fixed right away, before knowing the time windows for the subsequent groups. The universal constraint system contains a single constraint, demanding that the disclosed time windows are comprised of time slots on average.

4.2 Computational Results

The used solver utilizes CPLEX (12.6.1) as its black-box LP solver to solve the relaxations and all experiments were run with AMD Ryzen 9 5900X processors.

First we provide details on the benefit of utilizing the LP-relaxation with fixed scenario as given in Definition 2 compared to the standard LP at each decision node. Therefore, we consider the following testset:

  • selection instances with items, scenarios per period and periods

  • assignment instances with , scenarios per period and periods

  • runway scheduling instances with planes, runways, time slot and periods

In Table 2, as one of our major results, the overall runtimes when using the basic LP-relaxation and the LP-relaxation with fixed scenario are display.

used relaxation selection assignment runway
LP 29 501 7 152 12 902
LP with fixed scenario 348 837 4 520
Table 2: Overall runtime (in seconds) when only using the standard LP-relaxation vs. the LP-relaxation with fixed scenario.

In each case, explicitly setting the universally quantified to a fixed scenario results in a massive speedup that is most impressive for the selection instances. This emphasizes, that partially incorporating the worst-case nature of the underlying problem into the basic LP-relaxation is clearly beneficial and does not have any negative side effects: the bounds of the variables in the LP-relaxation have to be updated at each search node anyway and fixing the universally quantified variables even decreases the number of free variables in the resulting LP.

We now investigate how the use of the more sophisticated -relaxation in the first variable block changes the solver’s behavior. Therefore, the scenario set is built from (sub)scenarios, with . In case of only the LP-relaxation with fixed scenario is utilized in the first variable block. The used testset consists of the following instances

  • selection instances with items, scenarios per period and periods

  • assignment instances with , scenarios per period and periods

  • runway scheduling instances with planes, runways, time slot and periods

As one indicator we consider the number of decision nodes visited during the optimization phase of the search. We denote the number of visited decision nodes when solving instance with scenarios used to build the corresponding -relaxation. We compare each run with to the basic run with by considering the relative difference . If , i.e. if fewer decision nodes were visited while using the -relaxation, is negative, with its absolute value indicating the percentage savings. Similarly, if , is positive. The data on all instances is cumulated in Figure 1 showing the corresponding box plots111

Box plots are created using the macro psboxplot of the LaTeX package pst-plot15. The interquantile range factor, defining the area of outliers, is set to 1.5 by default.

.

(a) Selection
(b) Assignment
(c) Runway
Figure 1: Boxplots of the values for all three testset and

It can be seen that the median of the relative difference values is always negative and tends to decrease when more scenarios are considered in , i.e. the larger the scenario set the fewer decision nodes have to be visited during the search. Note that compared to the box plots for the selection and runway instances, for the assignment instances the upper whisker remains at a rather high level. But does a decreasing number of visited decision nodes also result in a lower runtime? For now consider the columns of Table 3 representing the heuristic scenario selection as presented in Section 3.2.

selection instances assignment instances runway instances
heuristic random heuristic random heuristic random
12 561 53 348 2 091 1 853 33 335 32 401
11 324 35 316 2 111 1 865 29 313 30 418
9 900 30 970 2 022 2 046 25 876 26 412
9 700 31 158 2 210 2 232 25 876 26 101
9 394 29 087 2 220 2 708 23 915 24 795
9 030 27 503 2 931 3 718 23 958 24 860
8 843 26 857 4 223 7 300 21 788 26 777
9 149 26 590 8 632 17 400 23 073 30 292
Table 3: Overall runtime (in seconds) when using the -relaxation with heuristic and random scenario selection

Both for the selection and the runway scheduling problem the overall runtimes tend to decrease when increases. Compared to only using the LP-relaxation with fixed scenario (), the runtimes decreased up to about 30% and 35% for the selection and runway scheduling instances, respectively. The slightly increased runtime for indicates that the solution time of such a large relaxation can no longer be compensated by fewer visited decision nodes. For the assignment instances, however, the overall runtime increases, up to a factor of four times the runtime when solely using the LP-relaxation with fixed scenario. Hence, even though fewer nodes are visited, the time it takes to process and generate information at these nodes increases considerably for this type of problem.

In Table 3 we additionally provide information on how well our scenario building routine performs on the considered testset. Therefore, instead of extending the most frequently visited (sub)scenarios via Algorithm 1, the scenario set now contains random scenarios. Similiarly, for the LP-relaxation with fixed scenario, we replace the heuristic selection in lines 3 and 4 of Algorithm 1 by randomly assigning the value or . Note, however, that even though the killer and VSIDS information is neglected while building the relaxation, it is still utilized in other situations during the search. The overall runtimes are shown in the according columns of Table 3. For the selection problem, randomly selecting the scenario results in a runtime about three times longer compared to using the heuristic selection process. For the runway instances, our heuristic also slightly outperforms the use of random scenarios. For the assignment instances the random scenario selection tends to be more favorable when only few scenarios are involved.

5 Conclusion and Outlook

We investigated how adaptive relaxations influence our search-based solution algorithm for multistage robust optimization problems. Our experimental results show that incorporating a single scenario in the standard LP-relaxation significantly speeds up the search process and clearly dominates the basic LP-relaxation. Furthermore, the use of the -relaxation which incorporates a subset of scenarios in a slim DEP, considerably decreases the number of visited nodes, even if only utilized in the very first variable block. While this smaller search space also resulted in a faster solution time for multistage selection and runway scheduling problems, the solution time tended to increase for multistage assignment instances. Additionally, we showed that our scenario selection heuristic outperforms a random scenario selection.

Several research questions arise from the presented experimental results. Is it possible to improve the heuristic scenario selection? Currently our heuristic focuses on including seemingly harmful scenarios but does not consider the diversity of the scenario set

, which might be one reason why using random scenarios already works quite well on specific problems. In contrast to our currently implemented search-information-based scenario selection heuristic, we find it interesting to deploy AI methods in order to classify scenarios as relevant and irrelevant for general QIP. Additionally, relevant characteristics of instances have to be found, in order to dynamically adjust the size of the used scenario set

. Furthermore, deploying the -relaxation in all—not only the very first—variable blocks is a very promising yet challenging task, as the implementation of such a frequently modified -relaxation must be done carefully. In this case having the ability to update all considered scenarios in each decision node is also of interest, in particular as our results showed that having few scenarios in the relaxation is already very beneficial.

References

  • [1] Achterberg, T., Koch, T., Martin, A.: Branching rules revisited. Operations Research Letters 33(1), 42–54 (2005)
  • [2] Akl, S., Newborn, M.: The principal continuation and the killer heuristic. In: Proceedings of the 1977 annual conference, ACM ’77, Seattle, Washington, USA. pp. 466–473 (1977)
  • [3]

    Balas, E.: Projection and lifting in combinatorial optimization. In: Jünger, M., Naddef, D. (eds.) Computational Combinatorial Optimization: Optimal or Provably Near-Optimal Solutions. pp. 26–56. Springer (2001)

  • [4] Ben-Tal, A., Ghaoui, L.E., Nemirovski, A.: Robust Optimization. Princeton University Press (2009)
  • [5] Bertsimas, D., Dunning, I.: Multistage robust mixed-integer optimization with adaptive partitions. Operations Research 64(4), 980–998 (2016)
  • [6] Bertsimas, D., Georghiou, A.: Design of near optimal decision rules in multistage adaptive mixed-integer optimization. Operations Research 63(3), 610–627 (2015)
  • [7]

    Cadoli, M., Schaerf, M., Giovanardi, A., Giovanardi, M.: An algorithm to evaluate quantified boolean formulae and its experimental evaluation. Journal of Automated Reasoning

    28(2), 101–142 (2002)
  • [8]

    Campbell, M., Marsland, T.: A comparison of minimax tree search algorithms. Artificial Intelligence

    20(4), 347–367 (1983)
  • [9] Ceria, S., Cordier, C., Marchand, H., Wolsey, L.A.: Cutting planes for integer programs with general integer variables. Math. programming 81(2), 201–214 (1998)
  • [10] Chen, X., Van Beek, P.: Conflict-directed backjumping revisited. Journal of Artificial Intelligence Research 14, 53–81 (2001)
  • [11] Delage, E., Iancu, D.A.: Robust multistage decision making. In: The operations research revolution, pp. 20–46. INFORMS (2015)
  • [12] Donninger, C., Lorenz, U.: The chess monster Hydra. In: Field Programmable Logic and Application. pp. 927–932. Springer (2004)
  • [13]

    Ederer, T., Hartisch, M., Lorenz, U., Opfer, T., Wolf, J.: Yasol: An open source solver for quantified mixed integer programs. In: 15th International Conference on Advances in Computer Games, ACG 2017. pp. 224–233. Springer (2017)

  • [14] Ederer, T., Lorenz, U., Martin, A., Wolf, J.: Quantified linear programs: a computational study. In: European Symposium on Algorithms. pp. 203–214. Springer (2011)
  • [15] Giunchiglia, E., Narizzano, M., Tacchella, A.: Backjumping for quantified boolean logic satisfiability. Artificial Intelligence 145(1), 99–120 (2003)
  • [16] Giunchiglia, E., Narizzano, M., Tacchella, A., et al.: Learning for quantified Boolean logic satisfiability. In: Proceedings of the AAAI Conference on Artificial Intelligence. pp. 649–654 (2002)
  • [17] Goerigk, M., Hartisch, M.: Multistage robust discrete optimization via quantified integer programming. Under revision at Computers and Operations Research, arXiv preprint arXiv:2009.12256 (2021)
  • [18]

    Gupta, A., Pál, M., Ravi, R., Sinha, A.: Boosted sampling: Approximation algorithms for stochastic optimization. In: Proceedings of the Thirty-sixth Annual ACM Symposium on Theory of Computing. pp. 417–426. STOC ’04 (2004)

  • [19] Hartisch, M.: Quantified Integer Programming with Polyhedral and Decision-Dependent Uncertainty. Ph.D. thesis, University of Siegen, Germany (2020). https://doi.org/10.25819/ubsi/4841
  • [20] Hartisch, M., Ederer, T., Lorenz, U., Wolf, J.: Quantified integer programs with polyhedral uncertainty set. In: Computers and Games - 9th International Conference, CG 2016. pp. 156–166. Springer (2016)
  • [21] Hartisch, M., Lorenz, U.: Mastering uncertainty: Towards robust multistage optimization with decision dependent uncertainty. In: Pacific Rim International Conference on Artificial Intelligence. pp. 446–458. Springer (2019)
  • [22] Hartisch, M., Lorenz, U.: A novel application for game tree search-exploiting pruning mechanisms for quantified integer programs. In: Advances in Computer Games. pp. 66–78. Springer (2019)
  • [23] Hemmi, D., Tack, G., Wallace, M.: A recursive scenario decomposition algorithm for combinatorial multistage stochastic optimisation problems. In: Proceedings of the AAAI Conference on Artificial Intelligence. vol. 32 (2018)
  • [24] Huang, J., et al.: The effect of restarts on the efficiency of clause learning. In: IJCAI. vol. 7, pp. 2318–2323 (2007)
  • [25] Kall, P., Mayer, J.: Stochastic linear programming. Models, theory and computation. Springer (2005)
  • [26] Knuth, D., Moore, R.: An analysis of alpha-beta pruning. Artificial Intelligence 6(4), 293–326 (1975)
  • [27] Lonsing, F., Biere, A.: Depqbf: A dependency-aware qbf solver. Journal on Satisfiability, Boolean Modeling and Computation 7(2-3), 71–76 (2010)
  • [28] Lorenz, U., Wolf, J.: Solving multistage quantified linear optimization problems with the alpha–beta nested benders decomposition. EURO Journal on Computational Optimization 3(4), 349–370 (2015)
  • [29] Marques-Silva, J., Lynce, I., Malik, S.: Conflict-driven clause learning SAT solvers. In: Handbook of Satisfiability, pp. 131–153. ios Press (2009)
  • [30] Mercier, L., Van Hentenryck, P.: Performance analysis of online anticipatory algorithms for large multistage stochastic integer programs. In: IJCAI. pp. 1979–1984 (2007)
  • [31] Moskewicz, M.W., Madigan, C.F., Zhao, Y., Zhang, L., Malik, S.: Chaff: Engineering an efficient sat solver. In: Proceedings of the 38th annual Design Automation Conference. pp. 530–535 (2001)
  • [32] Papadimitriou, C.: Games against nature. Journal of Computer and System Sciences 31(2), 288–301 (1985)
  • [33] Pearl, J.: Scout: A simple game-searching algorithm with proven optimal properties. In: Proceedings of the First AAAI Conference on Artificial Intelligence. pp. 143–145. AAAI’80, AAAI Press (1980)
  • [34] Pijls, W., de Bruin, A.: Game tree algorithms and solution trees. Theoretical Computer Science 252(1), 197–215 (2001)
  • [35] Schaeffer, J.: The history heuristic and alpha-beta search enhancements in practice. IEEE transactions on pattern analysis and machine intelligence 11(11), 1203–1212 (1989)
  • [36] Shapiro, A.: A dynamic programming approach to adjustable robust optimization. Operations Research Letters 39(2), 83–87 (2011)
  • [37] Subramani, K.: Analyzing selected quantified integer programs. In: Automated Reasoning: Second International Joint Conference, IJCAR 2004. vol. 3097, pp. 342–356. Springer (2004)
  • [38] Takriti, S., Ahmed, S.: On robust optimization of two-stage systems. Math. Programming 99(1), 109–126 (2004)