EXPTIME-complete Research Articles

Efficient Computation of the Waiting Time and Fidelity in Quantum Repeater Chains

Quantum communication enables a host of applications that cannot be achieved by classical communication means, with provably secure communication as one of the prime examples. The distance that quantum communication schemes can cover via direct communication is fundamentally limited by losses on the communication channel. By means of quantum repeaters, the reach of these schemes can be extended and chains of quantum repeaters could in principle cover arbitrarily long distances. In this work, we provide two efficient algorithms for determining the generation time and fidelity of the first generated entangled pair between the end nodes of a quantum repeater chain. The runtime of the algorithms increases polynomially with the number of segments of the chain, which improves upon the exponential runtime of existing algorithms. Our first algorithm is probabilistic and can analyze refined versions of repeater chain protocols which include intermediate entanglement distillation. Our second algorithm computes the waiting time distribution up to a pre-specified truncation time, has faster runtime than the first one and is moreover exact up to machine precision. Using our proof-of-principle implementation, we are able to analyze repeater chains of thousands of segments for some parameter regimes. The algorithms thus serve as useful tools for the analysis of large quantum repeater chain protocols and topologies of the future quantum internet.

Learning Graphs from Noisy Epidemic Cascades

We consider the problem of learning the weighted edges of a graph by observing the noisy times of infection for multiple epidemic cascades on this graph. Past work has considered this problem when the cascade information, i.e., infection times, are known exactly. Though the noisy setting is well motivated by many epidemic processes (e.g., most human epidemics), to the best of our knowledge, very little is known about when it is solvable. Previous work on the no-noise setting critically uses the ordering information. If noise can reverse this -- a node's reported (noisy) infection time comes after the reported infection time of some node it infected -- then we are unable to see how previous results can be extended. We therefore tackle two versions of the noisy setting: the limited-noise setting, where we know noisy times of infections, and the extreme-noise setting, in which we only know whether or not a node was infected. We provide a polynomial time algorithm for recovering the structure of bidirectional trees in the extreme-noise setting, and show our algorithm matches lower bounds established in the no-noise setting, and hence is optimal. We extend our results for general degree-bounded graphs, where again we show that our (poly-time) algorithm can recover the structure of the graph with optimal sample complexity. We also provide the first efficient algorithm to learn the weights of the bidirectional tree in the limited-noise setting. Finally, we give a polynomial time algorithm for learning the weights of general bounded-degree graphs in the limited-noise setting. This algorithm extends to general graphs (at the price of exponential running time), proving the problem is solvable in the general case. All our algorithms work for any noise distribution, without any restriction on the variance.

Community Detection in Dynamic Social Networks: A Multi-Agent Aya based on Electric Field

In recent years, several approaches have been proposed in order to detect communities in social networks. Most of them suffer from the recurrent problems: no detection of overlapping communities, exponential running time, no detection of all possible communities transformations, don’t consider the properties of social members, inability to deal with large scale networks, etc. Multi-agent systems are very suitable for modeling the phenomena in which various autonomous entities in inter-actions able to evolve in a dynamic environment. Considering the advantages of multi-agent simulations for social networks, in the present study, an incremental multi-agent system based on electric field is proposed. In this approach, a group of autonomous agents work together to discover the dynamic communities. Indeed, an agent is associated to each detected community. To update its community according to the dynamic of its members, each agent creates an electric field around it. It applies an attractive force to add very connected and similar members and neighboring communities. In the same time, it applies a repulsive force to reject some members and to get away from other communities. These forces are based on the structural and attributes similarity. To study the performance of this approach, set of different experiments is performed. The obtained results show the efficiency of the proposed model that was able to overcome all mentioned problems.

Live Placement of Interdependent Virtual Machines to Optimize Cloud Service Profits and Penalties on SLAs

This paper aims to optimize cloud services' net profits and penalties with live placement of interdependent virtual machines (VMs). This optimization is a complex task as it is difficult to achieve a successful compromise between penalties and net profits on service level contracts. This paper studies this optimization problem to minimize services' penalties and maximizing net profits while achieving live migrations of interdependent VMs. This VM's live placement optimization problem is a NP-hard problem with exponential running time. A mathematical model was designed and approximations were conducted with an efficient PCH/PCH' heuristic. This Mixed Integer Non-Linear programming (MNLP) formulation and heuristic for cloud services was tested where the overall services' penalty needs to be minimized, overall net profits have to be maximized, and where efficient live migrations of VMs is a concern. Simulation results show how cloud providers may live place VMs. Finally, our results show that a PCH/PCH' heuristic: (i) finds better solutions than the existing machines' configuration of Google traces; (ii) is suitable for large-sized instances of cloud services; (iii) performs better than FF, FFD, and CPLEX in terms of overall penalties and net profits; and (iv) runs in less than six minutes over the last day's data.

Fixed-Parameter Approximations for k-Center Problems in Low Highway Dimension Graphs

We consider the k-Center problem and some generalizations. For k-Center a set of kcenter vertices needs to be found in a graph G with edge lengths, such that the distance from any vertex of G to its nearest center is minimized. This problem naturally occurs in transportation networks, and therefore we model the inputs as graphs with bounded highway dimension, as proposed by Abraham et al. (SODA, pp 782–793, 2010). We show both approximation and fixed-parameter hardness results, and how to overcome them using fixed-parameter approximations, where the two paradigms are combined. In particular, we prove that for any $${\varepsilon }>0$$ computing a $$(2-{\varepsilon })$$ -approximation is W[2]-hard for parameter k, and NP-hard for graphs with highway dimension $$O(\log ^2 n)$$ . The latter does not rule out fixed-parameter $$(2-{\varepsilon })$$ -approximations for the highway dimension parameter h, but implies that such an algorithm must have at least doubly exponential running time in h if it exists, unless ETH fails. On the positive side, we show how to get below the approximation factor of 2 by combining the parameters k and h: we develop a fixed-parameter 3 / 2-approximation with running time $$2^{O(kh\log h)}\cdot n^{O(1)}$$ . Additionally we prove that, unless P=NP, our techniques cannot be used to compute fixed-parameter $$(2-{\varepsilon })$$ -approximations for only the parameter h. We also provide similar fixed-parameter approximations for the weightedk-Center and $$(k,{\mathcal {F}})$$ -Partition problems, which generalize k-Center.

An Exact Algorithm for Sorting by Weighted Preserving Genome Rearrangements.

The preserving Genome Sorting Problem (pGSP) asks for a shortest sequence of rearrangement operations that transforms a given gene order into another given gene order by using rearrangement operations that preserve common intervals, i.e., groups of genes that form an interval in both given gene orders. The wpGSP is the weighted version of the problem were each type of rearrangement operation has a weight and a minimum weight sequence of rearrangement operations is sought. An exact algorithm - called CREx2 - is presented, which solves the wpGSP for arbitrary gene orders and the following types of rearrangement operations: inversions, transpositions, inverse transpositions, and tandem duplication random loss operations. CREx2 has a (worst case) exponential runtime, but a linear runtime for problem instances where the common intervals are organized in a linear structure. The efficiency of CREx2 and its usefulness for phylogenetic analysis is shown empirically for gene orders of fungal mitochondrial genomes.

Equilibrium Computation and Robust Optimization in Zero Sum Games With Submodular Structure

We define a class of zero-sum games with combinatorial structure, where the best response problem of one player is to maximize a submodular function. For example, this class includes security games played on networks, as well as the problem of robustly optimizing a submodular function over the worst case from a set of scenarios. The challenge in computing equilibria is that both players' strategy spaces can be exponentially large. Accordingly, previous algorithms have worst-case exponential runtime and indeed fail to scale up on practical instances. We provide a pseudopolynomial-time algorithm which obtains a guaranteed (1 - 1/e)^2-approximate mixed strategy for the maximizing player. Our algorithm only requires access to a weakened version of a best response oracle for the minimizing player which runs in polynomial time. Experimental results for network security games and a robust budget allocation problem confirm that our algorithm delivers near-optimal solutions and scales to much larger instances than was previously possible.

Time Trend in Persistent Cognitive Decline: Results From the Longitudinal Aging Study Amsterdam.

To study time trends in the incidence of persistent cognitive decline (PCD), and whether an increase or decrease is explained by changes in well-known risk factors of dementia. Data from the Longitudinal Aging Study Amsterdam over a period of 20 years were used. Subsamples of 65-88 year-olds were selected at 7 waves, with numbers ranging from 1,800 to 1,165. Within-person change in cognitive functioning was used to determine PCD. In logistic generalized estimating equations (GEE), time (0, 3, 6, 9, 13, and 16 years) was the main predictor of 3-year PCD incidence. Explanatory variables were lagged one wave before incident PCD and included in separate models. PCD incidence was 2.5% at first, and 3.4% at last follow-up. GEE showed a positive time trend for PCD incidence [Exp(B)time = 1.042; p < .001]. None of the explanatory variables significantly changed the strength of the regression coefficient of linear time. Higher age, lower education, diabetes mellitus, smoking, lower body-mass index, and lower level of physical activity were associated with higher incidence of PCD. An increase in PCD incidence over time was found. Although well-known risk factors were associated with incidence per se, they did not explain the increase in incidence of PCD.

Stochastic runtime analysis of a Cross-Entropy algorithm for traveling salesman problems

This article analyzes the stochastic runtime of a Cross-Entropy algorithm mimicking an Max-Min Ant System with iteration-best reinforcement. It investigates the impact of magnitude of the sample size on the runtime to find optimal solutions for TSP instances.For simple TSP instances that have a {1,n}-valued distance function and a unique optimal solution, we show that sample size N∈ω(ln⁡n) results in a stochastically polynomial runtime, and N∈O(ln⁡n) results in a stochastically exponential runtime, where “stochastically” means with a probability of 1−n−ω(1), and n represents number of cities. In particular, for N∈ω(ln⁡n), we prove a stochastic runtime of O(N⋅n6) with the vertex-based random solution generation, and a stochastic runtime of O(N⋅n3ln⁡n) with the edge-based random solution generation. These runtimes are very close to the best known expected runtime for variants of Max-Min Ant System with best-so-far reinforcement by choosing a small N∈ω(ln⁡n). They are obtained for the stronger notion of stochastic runtime, and analyze the runtime in most cases.We also inspect more complex instances with n vertices positioned on an m×m grid. When the n vertices span a convex polygon, we obtain a stochastic runtime of O(n4m5+ϵ) with the vertex-based random solution generation, and a stochastic runtime of O(n3m5+ϵ) for the edge-based random solution generation. When there are k∈O(1) many vertices inside a convex polygon spanned by the other n−k vertices, we obtain a stochastic runtime of O(n4m5+ϵ+n6k−1mϵ) with the vertex-based random solution generation, and a stochastic runtime of O(n3m5+ϵ+n3kmϵ) with the edge-based random solution generation. These runtimes are better than the expected runtime for the so-called (μ+λ) EA reported in a recent article, and again obtained for the stronger notion of stochastic runtime.

DTL reconciliation repair

BackgroundMaximum parsimony phylogenetic tree reconciliation is an important technique for reconstructing the evolutionary histories of hosts and parasites, genes and species, and other interdependent pairs. Since the problem of finding temporally feasible maximum parsimony reconciliations is NP-complete, current methods use either exact algorithms with exponential worst-case running time or heuristics that do not guarantee optimal solutions.ResultsWe offer an efficient new approach that begins with a potentially infeasible maximum parsimony reconciliation and iteratively “repairs” it until it becomes temporally feasible.ConclusionsIn a non-trivial number of cases, this approach finds solutions that are better than those found by the widely-used Jane heuristic.

Trust-Based Task Assignment With Multiobjective Optimization in Service-Oriented Ad Hoc Networks

We propose and analyze a trust management protocol in service-oriented mobile ad hoc networks (MANETs) populated with service providers and service requesters, and demonstrate the resiliency and convergence properties against bad-mouthing, ballot-stuffing, opportunistic service, and self-promotion attacks. To demonstrate the applicability, we consider a mission-driven service-oriented MANET that must handle dynamically arriving tasks to achieve multiple conflicting objectives. We devise a trust-based heuristic algorithm based on auctioning with local knowledge of node status to solve this node-to-task assignment problem with multiobjective optimization (MOO) requirements. Our trust-based heuristic algorithm has a polynomial runtime complexity, rather than an exponential runtime complexity as in existing work, thus allowing dynamic node-to-task assignment to be performed at runtime. It outperforms a nontrust-based counterpart using blacklisting techniques while performing close to the ideal solution quality with perfect knowledge of node status over a wide range of environmental conditions. We conduct extensive sensitivity analysis of the results with respect to key design parameters and alternative trust protocol designs. We also develop a table-lookup method to apply the best trust protocol parameter settings upon detection of dynamically changing environmental conditions to maximize MOO performance.

Faster and Simpler Algorithm for Optimal Strategies of Blotto Game

In the Colonel Blotto game, which was initially introduced by Borel in 1921, two colonels simultaneously distribute their troops across different battlefields.The winner of each battlefield is determined independently by a winner-take-all rule. The ultimate payoff of each colonel is the number of battlefields he wins. This game is commonly used for analyzing a wide range of applications such as the U.S presidential election, innovative technology competitions, advertisements, etc. There have been persistent efforts for finding the optimal strategies for the Colonel Blotto game. After almost a century Ahmadinejad, Dehghani, Hajiaghayi, Lucier, Mahini, and Seddighin provided a poly-time algorithm for finding the optimal strategies. They first model the problem by a Linear Program (LP) with exponential number of constraints and use Ellipsoid method to solve it. However, despite the theoretical importance of their algorithm, it ishighly impractical. In general, even Simplex method (despite its exponential running-time) performs better than Ellipsoid method in practice. In this paper, we provide the first polynomial-size LP formulation of the optimal strategies for the Colonel Blotto game. We use linear extension techniques. Roughly speaking, we project the strategy space polytope to a higher dimensional space, which results in a lower number of facets for the polytope.We use this polynomial-size LP to provide a novel, simpler and significantly faster algorithm for finding the optimal strategies for the Colonel Blotto game. We further show this representation is asymptotically tight in terms of the number of constraints. We also extend our approach to multi-dimensional Colonel Blotto games, and implement our algorithm to observe interesting properties of Colonel Blotto; for example, we observe the behavior of players in the discrete model is very similar to the previously studied continuous model.

Doubly Stochastic Sequential Assignment Problem

AbstractThis article introduces the Doubly Stochastic Sequential Assignment Problem (DSSAP), an extension of the Sequential Stochastic Assignment Problem (SSAP), where sequentially arriving tasks are assigned to workers with random success rates. A given number of tasks arrive sequentially, each with a random value coming from a known distribution. On a task arrival, it must be assigned to one of the available workers, each with a random success rate coming from a known distribution. Optimal assignment policies are proposed for DSSAP under various assumptions on the random success rates. The optimal assignment algorithm for the general case of DSSAP, where workers have distinct success rate distribution, has an exponential running time. An approximation algorithm that achieves a fraction of the maximum total expected reward in a polynomial time is proposed. The results are illustrated by several numerical experiments. © 2016 Wiley Periodicals, Inc. Naval Research Logistics 63: 124–137, 2016

Efficient Verification-Driven Slicing of UML/OCL Class Diagrams

Model defects are a significant concern in the Model-Driven Development (MDD) paradigm, as model trans-formations and code generation may propagate errors present in the model to other notations where they are harder to detect and trace. Formal verification techniques can check the correctness of a model, but their high computational complexity can limit their scalability. Current approaches to this problem have an exponential worst-case run time. In this paper, we propose a slicing technique which breaks a model into several independent submodels from which irrelevant information can be abstracted to improve the scalability of the verification process. We consider a specific static model (UML class diagrams annotated with unrestricted OCL constraints) and a specific property to verify (satisfiability, i.e., whether it is possible to create objects without violating any constraints). The definition of the slicing procedure ensures that the property under verification is preserved after partitioning. Furthermore, the paper provides an evaluation of experimental results from a real-world case study.

Placing Virtual Machines to Optimize Cloud Gaming Experience

Optimizing cloud gaming experience is no easy task due to the complex tradeoff between gamer quality of experience (QoE) and provider net profit. We tackle the challenge and study an optimization problem to maximize the cloud gaming provider’s total profit while achieving just-good-enough QoE. We conduct measurement studies to derive the QoE and performance models. We formulate and optimally solve the problem. The optimization problem has exponential running time, and we develop an efficient heuristic algorithm. We also present an alternative formulation and algorithms for closed cloud gaming services with dedicated infrastructures, where the profit is not a concern and overall gaming QoE needs to be maximized. We present a prototype system and testbed using off-the-shelf virtualization software, to demonstrate the practicality and efficiency of our algorithms. Our experience on realizing the testbed sheds some lights on how cloud gaming providers may build up their own profitable services. Last, we conduct extensive trace-driven simulations to evaluate our proposed algorithms. The simulation results show that the proposed heuristic algorithms: (i) produce close-to-optimal solutions, (ii) scale to large cloud gaming services with 20,000 servers and 40,000 gamers, and (iii) outperform the state-of-the-art placement heuristic, e.g., by up to 3.5 times in terms of net profits.

On the complexity of asynchronous agreement against powerful adversaries

We introduce new techniques for proving lower bounds on the running time of randomized algorithms for asynchronous agreement against powerful adversaries. In particular, we define a strongly adaptive adversary that is computationally unbounded and has a limited ability to corrupt a dynamic subset of processors by erasing their memories. We demonstrate that the randomized agreement algorithms designed by Ben-Or and Bracha to tolerate crash or Byzantine failures in the asynchronous setting extend to defeat a strongly adaptive adversary. These algorithms have essentially perfect correctness and termination, but at the expense of exponential running time. In the case of the strongly adaptive adversary, we show that this dismally slow running time is inherent: we prove that any algorithm with essentially perfect correctness and termination against the strongly adaptive adversary must have exponential running time. We additionally interpret this result as yielding an enhanced understanding of the tools needed to simultaneously achieving perfect correctness and termination as well as fast running time for randomized algorithms tolerating crash or Byzantine failures.

Efficient schedulability tests for real-time embedded systems with urgent routines

Task scheduling is one of the key mechanisms to ensure timeliness in embedded real-time systems. Such systems have often the need to execute not only application tasks but also some urgent routines (e.g. error-detection actions, consistency checkers, interrupt handlers) with minimum latency. Although fixed-priority schedulers such as Rate-Monotonic (RM) are in line with this need, they usually make a low processor utilization available to the system. Moreover, this availability usually decreases with the number of considered tasks. If dynamic-priority schedulers such as Earliest Deadline First (EDF) are applied instead, high system utilization can be guaranteed but the minimum latency for executing urgent routines may not be ensured.In this paper we describe a scheduling model according to which urgent routines are executed at the highest priority level and all other system tasks are scheduled by EDF. We show that the guaranteed processor utilization for the assumed scheduling model is at least as high as the one provided by RM for two tasks, namely \(2(\sqrt{2}-1)\). Seven polynomial time tests for checking the system timeliness are derived and proved correct. The proposed tests are compared against each other and to an exact but exponential running time test.

On the runtime analysis of the Simple Genetic Algorithm

For many years it has been a challenge to analyze the time complexity of Genetic Algorithms (GAs) using stochastic selection together with crossover and mutation. This paper presents a rigorous runtime analysis of the well-known Simple Genetic Algorithm (SGA) for OneMax. It is proved that the SGA has exponential runtime with overwhelming probability for population sizes up to μ⩽n1/8−ε for some arbitrarily small constant ε and problem size n. To the best of our knowledge, this is the first time non-trivial lower bounds are obtained on the runtime of a standard crossover-based GA for a standard benchmark function. The presented techniques might serve as a first basis towards systematic runtime analyses of GAs.

Maximal and supremal tolerances in multiobjective linear programming

Let a multiobjective linear programming problem and any efficient solution be given. Tolerance analysis aims to compute interval tolerances for (possibly all) objective function coefficients such that the efficient solution remains efficient for any perturbation of the coefficients within the computed intervals. The known methods either yield tolerances that are not the maximal possible ones, or they consider perturbations of weights of the weighted sum scalarization only. We focus directly on perturbations of the objective function coefficients, which makes the approach independent on a scalarization technique used. In this paper, we propose a method for calculating the supremal tolerance (the maximal one need not exist). The main disadvantage of the method is the exponential running time in the worst case. Nevertheless, we show that the problem of determining the maximal/supremal tolerance is NP-hard, so an efficient (polynomial time) procedure is not likely to exist. We illustrate our approach on examples and present an application in transportation problems. Since the maximal tolerance may be small, we extend the notion to individual lower and upper tolerances for each objective function coefficient. An algorithm for computing maximal individual tolerances is proposed.

Computing Borcherds products

AbstractWe present an algorithm for computing Borcherds products, which has polynomial runtime. It deals efficiently with the bounds on Fourier expansion indices originating in Weyl chambers. Naive multiplication has exponential runtime due to inefficient handling of these bounds. An implementation of the new algorithm shows that it is also much faster in practice.