Downloads & Free Reading Options - Results

We study the problem of computing the upper bound of the discrete Fr\'{e}chet distance for imprecise input, and prove that the problem is NP-hard. This solves an open problem posed in 2010 by Ahn \emph{et al}. If shortcuts are allowed, we show that the upper bound of the discrete Fr\'{e}chet distance with shortcuts for imprecise input can be computed in polynomial time and we present several efficient algorithms.

In this study, we address the problem of answering queries over a peer-to-peer system of taxonomy-based sources. A taxonomy states subsumption relationships between negation-free DNF formulas on terms and negation-free conjunctions of terms. To the end of laying the foundations of our study, we first consider the centralized case, deriving the complexity of the decision problem and of query evaluation. We conclude by presenting an algorithm that is efficient in data complexity and is based on hypergraphs. More expressive forms of taxonomies are also investigated, which however lead to intractability. We then move to the distributed case, and introduce a logical model of a network of taxonomy-based sources. On such network, a distributed version of the centralized algorithm is then presented, based on a message passing paradigm, and its correctness is proved. We finally discuss optimization issues, and relate our work to the literature.

This paper considers the cooperation between a cognitive system and a primary system where multiple cognitive base stations (CBSs) relay the primary user's (PU) signals in exchange for more opportunity to transmit their own signals. The CBSs use amplify-and-forward (AF) relaying and coordinated beamforming to relay the primary signals and transmit their own signals. The objective is to minimize the overall transmit power of the CBSs given the rate requirements of the PU and the cognitive users (CUs). We show that the relaying matrices have unit rank and perform two functions: Matched filter receive beamforming and transmit beamforming. We then develop two efficient algorithms to find the optimal solution. The first one has linear convergence rate and is suitable for distributed implementation, while the second one enjoys superlinear convergence but requires centralized processing. Further, we derive the beamforming vectors for the linear conventional zero-forcing (CZF) and prior zero-forcing (PZF) schemes, which provide much simpler solutions. Simulation results demonstrate the improvement in terms of outage performance due to the cooperation between the primary and cognitive systems.

We consider the problem of ranking a set of OT constraints in a manner consistent with data. We speed up Tesar and Smolensky's RCD algorithm to be linear on the number of constraints. This finds a ranking so each attested form x_i beats or ties a particular competitor y_i. We also generalize RCD so each x_i beats or ties all possible competitors. Alas, this more realistic version of learning has no polynomial algorithm unless P=NP! Indeed, not even generation does. So one cannot improve qualitatively upon brute force: Merely checking that a single (given) ranking is consistent with given forms is coNP-complete if the surface forms are fully observed and Delta_2^p-complete if not. Indeed, OT generation is OptP-complete. As for ranking, determining whether any consistent ranking exists is coNP-hard (but in Delta_2^p) if the forms are fully observed, and Sigma_2^p-complete if not. Finally, we show that generation and ranking are easier in derivational theories: in P, and NP-complete.

Compute-and-Forward (C&F) has been proposed as an efficient strategy to reduce the backhaul load for the distributed antenna systems. Finding the optimal coefficients in C&F has commonly been treated as a shortest vector problem (SVP), which is N-P hard. The point of our work and of Sahraei's recent work is that the C&F coefficient problem can be much simpler. Due to the special structure of C&F, some low polynomial complexity optimal algorithms have recently been developed. However these methods can be applied to real valued channels and integer based lattices only. In this paper, we consider the complex valued channel with complex integer based lattices. For the first time, we propose a low polynomial complexity algorithm to find the optimal solution for the complex scenario. Then we propose a simple linear search algorithm which is conceptually suboptimal, however numerical results show that the performance degradation is negligible compared to the optimal method. Both algorithms are suitable for lattices over any algebraic integers, and significantly outperform the lattice reduction algorithm. The complexity of both algorithms are investigated both theoretically and numerically. The results show that our proposed algorithms achieve better performance-complexity trade-offs compared to the existing algorithms.

We consider the problem of learning the structure of Ising models (pairwise binary Markov random fields) from i.i.d. samples. While several methods have been proposed to accomplish this task, their relative merits and limitations remain somewhat obscure. By analyzing a number of concrete examples, we show that low-complexity algorithms often fail when the Markov random field develops long-range correlations. More precisely, this phenomenon appears to be related to the Ising model phase transition (although it does not coincide with it).

Abstract The knapsack problem is an optimization problem in computer science which involves determining the most valuable combination of items that can be packed into a knapsack (a container) with a limited capacity (weight or volume); the goal is to maximize the total profit of the items included in the knapsack without exceeding its capacity. This study extensively analyzes the knapsack problem, exploring the application of three prevalent heuristics: greedy, dynamic programming, and FPTAS algorithms implemented in Python. The study aims to assess how these algorithms perform differently, focusing on program complexity and computational speed. Our main objective is to compare these algorithms and determine the most effective one for solving the knapsack problem as well as to be chosen by the researchers and developers when dealing similar problem in real-world applications. Our methodology involved solving the knapsack problem using the three algorithms within a unified programming environment. We conducted experiments using varying input datasets and recorded the time complexities of the algorithms in each trial. Additionally, we performed Halstead complexity measurements to derive the volume of each algorithm for this study. Subsequently, we compared program complexity in Halstead metrics and computational speed for the three approaches. The research findings reveal that the Greedy algorithm demonstrates superior computational efficiency compared to both Dynamic Programming (D.P) and FPTAS algorithms across various test cases. To advance understanding of the knapsack problem, future research should focus on investigating the performance of other programming languages in addressing combinatorial optimization problems, which would provide valuable insights into language choice impact. Additionally, integrating parallel computing techniques could accelerate solution processes for large-scale problem instances.

How much can randomness help computation? Motivated by this general question and by volume computation, one of the few instances where randomness probably helps, we analyze a notion of dispersion and connect it to asymptotic convex geometry. We obtain a nearly quadratic lower bound on the complexity of randomized volume algorithms for convex bodies in R n (the current best algorithm has complexity roughly n 4 and is conjectured to be n 3 ). Our main tools, dispersion of random determinants and dispersion of the length of a random point from a convex body, are of independent interest and applicable more generally; in particular, the latter is closely related to the variance hypothesis from convex geometry. This geometric dispersion also leads to lower bounds for matrix problems and property testing. This is joint work with Luis Rademacher. ©2006 Microsoft Corporation. All rights reserved.

This document describes exploratory research on a distributed, trajectory oriented approach for traffic complexity management. The approach is to manage traffic complexity based on preserving trajectory flexibility and minimizing constraints. In particular, the document presents metrics for trajectory flexibility; a method for estimating these metrics based on discrete time and degree of freedom assumptions; a planning algorithm using these metrics to preserve flexibility; and preliminary experiments testing the impact of preserving trajectory flexibility on traffic complexity. The document also describes an early demonstration capability of the trajectory flexibility preservation function in the NASA Autonomous Operations Planner (AOP) platform.

The diagonal of a multivariate power series F is the univariate power series Diag(F) generated by the diagonal terms of F. Diagonals form an important class of power series; they occur frequently in number theory, theoretical physics and enumerative combinatorics. We study algorithmic questions related to diagonals in the case where F is the Taylor expansion of a bivariate rational function. It is classical that in this case Diag(F) is an algebraic function. We propose an algorithm that computes an annihilating polynomial for Diag(F). We give a precise bound on the size of this polynomial and show that generically, this polynomial is the minimal polynomial and that its size reaches the bound. The algorithm runs in time quasi-linear in this bound, which grows exponentially with the degree of the input rational function. We then address the related problem of enumerating directed lattice walks. The insight given by our study leads to a new method for expanding the generating power series of bridges, excursions and meanders. We show that their first N terms can be computed in quasi-linear complexity in N, without first computing a very large polynomial equation.

How much can randomness help computation? Motivated by this general question and by volume computation, one of the few instances where randomness provably helps, we analyze a notion of dispersion and connect it to asymptotic convex geometry. We obtain a nearly quadratic lower bound on the complexity of randomized volume algorithms for convex bodies in R^n (the current best algorithm has complexity roughly n^4, conjectured to be n^3). Our main tools, dispersion of random determinants and dispersion of the length of a random point from a convex body, are of independent interest and applicable more generally; in particular, the latter is closely related to the variance hypothesis from convex geometry. This geometric dispersion also leads to lower bounds for matrix problems and property testing.

How much can randomness help computation? Motivated by this general question and by volume computation, one of the few instances where randomness provably helps, we analyze a notion of dispersion and connect it to asymptotic convex geometry. We obtain a nearly quadratic lower bound on the complexity of randomized volume algorithms for convex bodies in R^n (the current best algorithm has complexity roughly n^4, conjectured to be n^3). Our main tools, dispersion of random determinants and dispersion of the length of a random point from a convex body, are of independent interest and applicable more generally; in particular, the latter is closely related to the variance hypothesis from convex geometry. This geometric dispersion also leads to lower bounds for matrix problems and property testing.

How much can randomness help computation? Motivated by this general question and by volume computation, one of the few instances where randomness provably helps, we analyze a notion of dispersion and connect it to asymptotic convex geometry. We obtain a nearly quadratic lower bound on the complexity of randomized volume algorithms for convex bodies in R^n (the current best algorithm has complexity roughly n^4, conjectured to be n^3). Our main tools, dispersion of random determinants and dispersion of the length of a random point from a convex body, are of independent interest and applicable more generally; in particular, the latter is closely related to the variance hypothesis from convex geometry. This geometric dispersion also leads to lower bounds for matrix problems and property testing.

Integrating value focused thinking with the shortest path problem results in a unique formulation called the multiobjective average shortest path problem. We prove this is NP-complete for general graphs. For directed acyclic graphs, an efficient algorithm and even faster heuristic are proposed. While the worst case error of the heuristic is proven unbounded, its average performance on random graphs is within 3% of the optimal solution. Additionally, a special case of the more general biobjective average shortest path problem is given, allowing tradeoffs between decreases in arc set cardinality and increases in multiobjective value; the algorithm to solve the average shortest path problem provides all the information needed to solve this more difficult biobjective problem. These concepts are then extended to the minimum cost flow problem creating a new formulation we name the multiobjective average minimum cost flow. This problem is proven NP-complete as well. For directed acyclic graphs, two efficient heuristics are developed, and although we prove the error of any successive average shortest path heuristic is in theory unbounded, they both perform very well on random graphs. Furthermore, we define a general biobjective average minimum cost flow problem. The information from the heuristics can be used to estimate the efficient frontier in a special case of this problem trading off total flow and multiobjective value. Finally, several variants of these two problems are discussed. Proofs are conjectured showing the conditions under which the problems are solvable in polynomial time and when they remain NP-complete.

This project considers the dynamic spectrum management (DSM) problem whereby multiple users sharing a common frequency band must choose their transmit power spectra jointly in response to physical channel conditions including the effects of interference. The goal of the users is to maximize a system-wide utility function (e.g., weighted sum-rate of all users), subject to individual power constraints. The proposed work will focus on a general DSM problem formulation which allows correlated signaling rather than being restricted to the conventional independent orthogonal signaling such as OFDM. The general formulation will exploit the concept of 'interference alignment' which is known to provide substantial rate gain over OFDM signalling for general interference channels. We have successfully analyzed the complexity to characterize the optimal spectrum sharing policies and beamforming strategies in interfering broadcast networks and developed efficient computational methods for optimal resource allocations in such networks.

It is becoming increasingly apparent that probabilistic approaches can overcome conservatism and computational complexity of the classical worst-case deterministic framework and may lead to designs that are actually safer. In this paper we argue that a comprehensive probabilistic robustness analysis requires a detailed evaluation of the robustness function and we show that such evaluation can be performed with essentially any desired accuracy and confidence using algorithms with complexity linear in the dimension of the uncertainty space. Moreover, we show that the average memory requirements of such algorithms are absolutely bounded and well within the capabilities of today's computers. In addition to efficiency, our approach permits control over statistical sampling error and the error due to discretization of the uncertainty radius. For a specific level of tolerance of the discretization error, our techniques provide an efficiency improvement upon conventional methods which is inversely proportional to the accuracy level; i.e., our algorithms get better as the demands for accuracy increase.

Since October 1, 1979, research in Complexity Theory and Combinatorial Algorithms at the Department of Computer Science at the University of Illinois was supported by the Office of Naval Research. During this period of time, research work was carried out in the areas of Computational Complexity Theory, Scheduling Algorithms, Graph Algorithms, Dynamic Programming, and Fault- Tolerance Computing. We summarize here our accomplishments and our future plans, and we wish to request continued support for the period of October 1, 1980 - September 30, 1982 from ONR for research in these areas. Scheduling to meet deadlines -- The problem of scheduling jobs to meet their deadlines was studied. Given a set of jobs each of which is specified by three parameters, ready time, deadline, and computation time, we want to schedule them on a computer system so that, if possible, all deadlines will be met. Furthermore, if indeed all deadlines can be met, we want to know the possibility of completing the executing of each job so that there will be a 'slack time' between the time of completion and the deadline. In particular, the following model is used: There is a single processor in the computing system. Each job consists of an infinite stream of periodic and identical requests. A request is ready when it arrives and should be completed prior to the arrival of the next request of the same job. The execution of a job can be interrupted and be resumed later on.

Since October 1, 1979, research in Complexity Theory and Combinatorial Algorithms at the Department of Computer Science at the University of Illinois was supported by the Office of Naval Research. During this period of time, research work was carried out in the areas of Computational Complexity Theory, Scheduling Algorithms, Graph Algorithms, Dynamic Programming, and Fault- Tolerance Computing. We summarize here our accomplishments and our future plans, and we wish to request continued support for the period of October 1, 1980 - September 30, 1982 from ONR for research in these areas. Scheduling to meet deadlines -- The problem of scheduling jobs to meet their deadlines was studied. Given a set of jobs each of which is specified by three parameters, ready time, deadline, and computation time, we want to schedule them on a computer system so that, if possible, all deadlines will be met. Furthermore, if indeed all deadlines can be met, we want to know the possibility of completing the executing of each job so that there will be a 'slack time' between the time of completion and the deadline. In particular, the following model is used: There is a single processor in the computing system. Each job consists of an infinite stream of periodic and identical requests. A request is ready when it arrives and should be completed prior to the arrival of the next request of the same job. The execution of a job can be interrupted and be resumed later on.

A very brief introduction to tropical and idempotent mathematics is presented. Tropical mathematics can be treated as a result of a dequantization of the traditional mathematics as the Planck constant tends to zero taking imaginary values. In the framework of idempotent mathematics usually constructions and algorithms are more simple with respect to their traditional analogs. We especially examine algorithms of tropical/idempotent mathematics generated by a collection of basic semiring (or semifield) operations and other "good" operations. Every algorithm of this type has an interval version. The complexity of this interval version coincides with the complexity of the initial algorithm. The interval version of an algorithm of this type gives exact interval estimates for the corresponding output data. Algorithms of linear algebra over idempotent and semirings are examined. In this case, basic algorithms are polynomial as well as their interval versions. This situation is very different from the traditional linear algebra, where basic algorithms are polynomial but the corresponding interval versions are NP-hard and interval estimates are not exact.

We analyze relationships between quantum computation and a family of generalizations of the Jones polynomial. Extending recent work by Aharonov et al., we give efficient quantum circuits for implementing the unitary Jones-Wenzl representations of the braid group. We use these to provide new quantum algorithms for approximately evaluating a family of specializations of the HOMFLYPT two-variable polynomial of trace closures of braids. We also give algorithms for approximating the Jones polynomial of a general class of closures of braids at roots of unity. Next we provide a self-contained proof of a result of Freedman et al. that any quantum computation can be replaced by an additive approximation of the Jones polynomial, evaluated at almost any primitive root of unity. Our proof encodes two-qubit unitaries into the rectangular representation of the eight-strand braid group. We then give QCMA-complete and PSPACE-complete problems which are based on braids. We conclude with direct proofs that evaluating the Jones polynomial of the plat closure at most primitive roots of unity is a #P-hard problem, while learning its most significant bit is PP-hard, circumventing the usual route through the Tutte polynomial and graph coloring.

Carrier-grade networks comprise several layers where different protocols coexist. Nowadays, most of these networks have different control planes to manage routing on different layers, leading to a suboptimal use of the network resources and additional operational costs. However, some routers are able to encapsulate, decapsulate and convert protocols and act as a liaison between these layers. A unified control plane would be useful to optimize the use of the network resources and automate the routing configurations. Software-Defined Networking (SDN) based architectures, such as OpenFlow, offer a chance to design such a control plane. One of the most important problems to deal with in this design is the path computation process. Classical path computation algorithms cannot resolve the problem as they do not take into account encapsulations and conversions of protocols. In this paper, we propose algorithms to solve this problem and study several cases: Path computation without bandwidth constraint, under bandwidth constraint and under other Quality of Service constraints. We study the complexity and the scalability of our algorithms and evaluate their performances on real topologies. The results show that they outperform the previous ones proposed in the literature.

Carrier-grade networks comprise several layers where different protocols coexist. Nowadays, most of these networks have different control planes to manage routing on different layers, leading to a suboptimal use of the network resources and additional operational costs. However, some routers are able to encapsulate, decapsulate and convert protocols and act as a liaison between these layers. A unified control plane would be useful to optimize the use of the network resources and automate the routing configurations. Software-Defined Networking (SDN) based architectures, such as OpenFlow, offer a chance to design such a control plane. One of the most important problems to deal with in this design is the path computation process. Classical path computation algorithms cannot resolve the problem as they do not take into account encapsulations and conversions of protocols. In this paper, we propose algorithms to solve this problem and study several cases: Path computation without bandwidth constraint, under bandwidth constraint and under other Quality of Service constraints. We study the complexity and the scalability of our algorithms and evaluate their performances on real topologies. The results show that they outperform the previous ones proposed in the literature.

Frank-Wolfe algorithms for convex minimization have recently gained considerable attention from the Optimization and Machine Learning communities, as their properties make them a suitable choice in a variety of applications. However, as each iteration requires to optimize a linear model, a clever implementation is crucial to make such algorithms viable on large-scale datasets. For this purpose, approximation strategies based on a random sampling have been proposed by several researchers. In this work, we perform an experimental study on the effectiveness of these techniques, analyze possible alternatives and provide some guidelines based on our results.

The inefficiency of the Wardrop equilibrium of nonatomic routing games can be eliminated by placing tolls on the edges of a network so that the socially optimal flow is induced as an equilibrium flow. A solution where the minimum number of edges are tolled may be preferable over others due to its ease of implementation in real networks. In this paper we consider the minimum tollbooth (MINTB) problem, which seeks social optimum inducing tolls with minimum support. We prove for single commodity networks with linear latencies that the problem is NP-hard to approximate within a factor of $1.1377$ through a reduction from the minimum vertex cover problem. Insights from network design motivate us to formulate a new variation of the problem where, in addition to placing tolls, it is allowed to remove unused edges by the social optimum. We prove that this new problem remains NP-hard even for single commodity networks with linear latencies, using a reduction from the partition problem. On the positive side, we give the first exact polynomial solution to the MINTB problem in an important class of graphs---series-parallel graphs. Our algorithm solves MINTB by first tabulating the candidate solutions for subgraphs of the series-parallel network and then combining them optimally.

Integer least-squares problems, concerned with solving a system of equations where the components of the unknown vector are integer-valued, arise in a wide range of applications. In many scenarios the unknown vector is sparse, i.e., a large fraction of its entries are zero. Examples include applications in wireless communications, digital fingerprinting, and array-comparative genomic hybridization systems. Sphere decoding, commonly used for solving integer least-squares problems, can utilize the knowledge about sparsity of the unknown vector to perform computationally efficient search for the solution. In this paper, we formulate and analyze the sparsity-aware sphere decoding algorithm that imposes $\ell_0$-norm constraint on the admissible solution. Analytical expressions for the expected complexity of the algorithm for alphabets typical of sparse channel estimation and source allocation applications are derived and validated through extensive simulations. The results demonstrate superior performance and speed of sparsity-aware sphere decoder compared to the conventional sparsity-unaware sphere decoding algorithm. Moreover, variance of the complexity of the sparsity-aware sphere decoding algorithm for binary alphabets is derived. The search space of the proposed algorithm can be further reduced by imposing lower bounds on the value of the objective function. The algorithm is modified to allow for such a lower bounding technique and simulations illustrating efficacy of the method are presented. Performance of the algorithm is demonstrated in an application to sparse channel estimation, where it is shown that sparsity-aware sphere decoder performs close to theoretical lower limits.

The computational complexity of internal diffusion-limited aggregation (DLA) is examined from both a theoretical and a practical point of view. We show that for two or more dimensions, the problem of predicting the cluster from a given set of paths is complete for the complexity class CC, the subset of P characterized by circuits composed of comparator gates. CC-completeness is believed to imply that, in the worst case, growing a cluster of size n requires polynomial time in n even on a parallel computer. A parallel relaxation algorithm is presented that uses the fact that clusters are nearly spherical to guess the cluster from a given set of paths, and then corrects defects in the guessed cluster through a non-local annihilation process. The parallel running time of the relaxation algorithm for two-dimensional internal DLA is studied by simulating it on a serial computer. The numerical results are compatible with a running time that is either polylogarithmic in n or a small power of n. Thus the computational resources needed to grow large clusters are significantly less on average than the worst-case analysis would suggest. For a parallel machine with k processors, we show that random clusters in d dimensions can be generated in O((n/k + log k) n^{2/d}) steps. This is a significant speedup over explicit sequential simulation, which takes O(n^{1+2/d}) time on average. Finally, we show that in one dimension internal DLA can be predicted in O(log n) parallel time, and so is in the complexity class NC.

The computational complexity of solving random 3-Satisfiability (3-SAT) problems is investigated. 3-SAT is a representative example of hard computational tasks; it consists in knowing whether a set of alpha N randomly drawn logical constraints involving N Boolean variables can be satisfied altogether or not. Widely used solving procedures, as the Davis-Putnam-Loveland-Logeman (DPLL) algorithm, perform a systematic search for a solution, through a sequence of trials and errors represented by a search tree. In the present study, we identify, using theory and numerical experiments, easy (size of the search tree scaling polynomially with N) and hard (exponential scaling) regimes as a function of the ratio alpha of constraints per variable. The typical complexity is explicitly calculated in the different regimes, in very good agreement with numerical simulations. Our theoretical approach is based on the analysis of the growth of the branches in the search tree under the operation of DPLL. On each branch, the initial 3-SAT problem is dynamically turned into a more generic 2+p-SAT problem, where p and 1-p are the fractions of constraints involving three and two variables respectively. The growth of each branch is monitored by the dynamical evolution of alpha and p and is represented by a trajectory in the static phase diagram of the random 2+p-SAT problem. Depending on whether or not the trajectories cross the boundary between phases, single branches or full trees are generated by DPLL, resulting in easy or hard resolutions.

Presentation slides 

viii, 239 p. : 25 cm

Since October 1, 1979, research in Complexity Theory and Combinatorial Algorithms at the Department of Computer Science at the University of Illinois was supported by the Office of Naval Research. During this period of time, research work was carried out in the areas of Computational Complexity Theory, Scheduling Algorithms, Graph Algorithms, Dynamic Programming, and Fault- Tolerance Computing. We summarize here our accomplishments and our future plans, and we wish to request continued support for the period of October 1, 1980 - September 30, 1982 from ONR for research in these areas. Scheduling to meet deadlines -- The problem of scheduling jobs to meet their deadlines was studied. Given a set of jobs each of which is specified by three parameters, ready time, deadline, and computation time, we want to schedule them on a computer system so that, if possible, all deadlines will be met. Furthermore, if indeed all deadlines can be met, we want to know the possibility of completing the executing of each job so that there will be a 'slack time' between the time of completion and the deadline. In particular, the following model is used: There is a single processor in the computing system. Each job consists of an infinite stream of periodic and identical requests. A request is ready when it arrives and should be completed prior to the arrival of the next request of the same job. The execution of a job can be interrupted and be resumed later on.

Since October 1, 1979, research in Complexity Theory and Combinatorial Algorithms at the Department of Computer Science at the University of Illinois was supported by the Office of Naval Research. During this period of time, research work was carried out in the areas of Computational Complexity Theory, Scheduling Algorithms, Graph Algorithms, Dynamic Programming, and Fault- Tolerance Computing. We summarize here our accomplishments and our future plans, and we wish to request continued support for the period of October 1, 1980 - September 30, 1982 from ONR for research in these areas. Scheduling to meet deadlines -- The problem of scheduling jobs to meet their deadlines was studied. Given a set of jobs each of which is specified by three parameters, ready time, deadline, and computation time, we want to schedule them on a computer system so that, if possible, all deadlines will be met. Furthermore, if indeed all deadlines can be met, we want to know the possibility of completing the executing of each job so that there will be a 'slack time' between the time of completion and the deadline. In particular, the following model is used: There is a single processor in the computing system. Each job consists of an infinite stream of periodic and identical requests. A request is ready when it arrives and should be completed prior to the arrival of the next request of the same job. The execution of a job can be interrupted and be resumed later on.

Since October 1, 1979, research in Complexity Theory and Combinatorial Algorithms at the Department of Computer Science at the University of Illinois was supported by the Office of Naval Research. During this period of time, research work was carried out in the areas of Computational Complexity Theory, Scheduling Algorithms, Graph Algorithms, Dynamic Programming, and Fault- Tolerance Computing. We summarize here our accomplishments and our future plans, and we wish to request continued support for the period of October 1, 1980 - September 30, 1982 from ONR for research in these areas. Scheduling to meet deadlines -- The problem of scheduling jobs to meet their deadlines was studied. Given a set of jobs each of which is specified by three parameters, ready time, deadline, and computation time, we want to schedule them on a computer system so that, if possible, all deadlines will be met. Furthermore, if indeed all deadlines can be met, we want to know the possibility of completing the executing of each job so that there will be a 'slack time' between the time of completion and the deadline. In particular, the following model is used: There is a single processor in the computing system. Each job consists of an infinite stream of periodic and identical requests. A request is ready when it arrives and should be completed prior to the arrival of the next request of the same job. The execution of a job can be interrupted and be resumed later on.

Talk by Marc Wanner - Predicting Ground State Properties: Constant Sample Complexity and Deep Learning Algorithms @QTMLConference

The Turaev-Viro invariants are a powerful family of topological invariants for distinguishing between different 3-manifolds. They are invaluable for mathematical software, but current algorithms to compute them require exponential time. The invariants are parameterised by an integer $r \geq 3$. We resolve the question of complexity for $r=3$ and $r=4$, giving simple proofs that computing Turaev-Viro invariants for $r=3$ is polynomial time, but for $r=4$ is \#P-hard. Moreover, we give an explicit fixed-parameter tractable algorithm for arbitrary $r$, and show through concrete implementation and experimentation that this algorithm is practical---and indeed preferable---to the prior state of the art for real computation.

In this paper we are concerned with finding the vertices of the Voronoi cell of a Euclidean lattice. Given a basis of a lattice, we prove that computing the number of vertices is a #P-hard problem. On the other hand we describe an algorithm for this problem which is especially suited for low dimensional (say dimensions at most 12) and for highly-symmetric lattices. We use our implementation, which drastically outperforms those of current computer algebra systems, to find the vertices of Voronoi cells and quantizer constants of some prominent lattices.

In this paper we are concerned with finding the vertices of the Voronoi cell of a Euclidean lattice. Given a basis of a lattice, we prove that computing the number of vertices is a #P-hard problem. On the other hand we describe an algorithm for this problem which is especially suited for low dimensional (say dimensions at most 12) and for highly-symmetric lattices. We use our implementation, which drastically outperforms those of current computer algebra systems, to find the vertices of Voronoi cells and quantizer constants of some prominent lattices.

The local minimum degree of a graph is the minimum degree that can be reached by means of local complementation. For any n, there exist graphs of order n which have a local minimum degree at least 0.189n, or at least 0.110n when restricted to bipartite graphs. Regarding the upper bound, we show that for any graph of order n, its local minimum degree is at most 3n/8+o(n) and n/4+o(n) for bipartite graphs, improving the known n/2 upper bound. We also prove that the local minimum degree is smaller than half of the vertex cover number (up to a logarithmic term). The local minimum degree problem is NP-Complete and hard to approximate. We show that this problem, even when restricted to bipartite graphs, is in W[2] and FPT-equivalent to the EvenSet problem, which W[1]-hardness is a long standing open question. Finally, we show that the local minimum degree is computed by a O*(1.938^n)-algorithm, and a O*(1.466^n)-algorithm for the bipartite graphs.

We study the problem of minimizing the sum of a smooth convex function and a convex block-separable regularizer and propose a new randomized coordinate descent method, which we call ALPHA. Our method at every iteration updates a random subset of coordinates, following an arbitrary distribution. No coordinate descent methods capable to handle an arbitrary sampling have been studied in the literature before for this problem. ALPHA is a remarkably flexible algorithm: in special cases, it reduces to deterministic and randomized methods such as gradient descent, coordinate descent, parallel coordinate descent and distributed coordinate descent -- both in nonaccelerated and accelerated variants. The variants with arbitrary (or importance) sampling are new. We provide a complexity analysis of ALPHA, from which we deduce as a direct corollary complexity bounds for its many variants, all matching or improving best known bounds.

This paper establishes some of the fundamental barriers in the theory of computations and finally settles the long standing computational spectral problem. Due to these barriers, there are problems at the heart of computational theory that do not fit into classical complexity theory. Many computational problems can be solved as follows: a sequence of approximations is created by an algorithm, and the solution to the problem is the limit of this sequence. However, as we demonstrate, for several basic problems in computations (computing spectra of operators, inverse problems or roots of polynomials using rational maps) such a procedure based on one limit is impossible. Yet, one can compute solutions to these problems, but only by using several limits. This may come as a surprise, however, this touches onto the boundaries of computational mathematics. To analyze this phenomenon we use the Solvability Complexity Index (SCI). The SCI is the smallest number of limits needed in the computation. We show that the SCI of spectra and essential spectra of operators is equal to three, and that the SCI of spectra of self-adjoint operators is equal to two, thus providing the lower bound barriers and the first algorithms to compute such spectra in two and three limits. This finally settles the long standing computational spectral problem. In addition, we provide bounds for the SCI of spectra of classes of Schr\"{o}dinger operators, thus we affirmatively answer the long standing question on whether or not these spectra can actually be computed. The SCI yields a framework for understanding barriers in computations. It has a direct link to the Arithmetical Hierarchy, and we demonstrate how the impossibility result of McMullen on polynomial root finding with rational maps in one limit and the results of Doyle and McMullen on solving the quintic in several limits can be put in the SCI framework.

Since October 1, 1979, research in Complexity Theory and Combinatorial Algorithms at the Department of Computer Science at the University of Illinois was supported by the Office of Naval Research. During this period of time, research work was carried out in the areas of Computational Complexity Theory, Scheduling Algorithms, Graph Algorithms, Dynamic Programming, and Fault- Tolerance Computing. We summarize here our accomplishments and our future plans, and we wish to request continued support for the period of October 1, 1980 - September 30, 1982 from ONR for research in these areas. Scheduling to meet deadlines -- The problem of scheduling jobs to meet their deadlines was studied. Given a set of jobs each of which is specified by three parameters, ready time, deadline, and computation time, we want to schedule them on a computer system so that, if possible, all deadlines will be met. Furthermore, if indeed all deadlines can be met, we want to know the possibility of completing the executing of each job so that there will be a 'slack time' between the time of completion and the deadline. In particular, the following model is used: There is a single processor in the computing system. Each job consists of an infinite stream of periodic and identical requests. A request is ready when it arrives and should be completed prior to the arrival of the next request of the same job. The execution of a job can be interrupted and be resumed later on.

During the period of the contract, 6/15/86-7/31/89, we have develop: I). A parallel multilevel-multiresolution algorithm for Image Processing and low-level Robot vision tasks, II). A Bayesian/Geometric Framework for 3-D shape estimation from 2-D images, appropriate for object recognition and other Robot tasks III). A procedure for rotation and scale invariant representation (coding) and recognition of textures; a computationally efficient algorithm for estimating Markov Random Fields, IV). We have obtained mathematical results concerning convergence and speed of convergence of computational algorithms such as the annealing algorithm, and have studied mathematically the consistency and asymptotic normality of Maximum Likelihood Estimators for Gibbs distributions. Keywords: Computer vision. (KR)

ADA121995

Estimating the p-th frequency moment of data stream is a very heavily studied problem. The problem is actually trivial when p = 1, assuming the strict Turnstile model. The sample complexity of our proposed algorithm is essentially O(1) near p=1. This is a very large improvement over the previously believed O(1/eps^2) bound. The proposed algorithm makes the long-standing problem of entropy estimation an easy task, as verified by the experiments included in the appendix.

We consider the problem of computing the Euler characteristic of an abstract simplicial complex given by its vertices and facets. We show that this problem is #P-complete and present two new practical algorithms for computing Euler characteristic. The two new algorithms are derived using combinatorial commutative algebra and we also give a second description of them that requires no algebra. We present experiments showing that the two new algorithms can be implemented to be faster than previous Euler characteristic implementations by a large margin.

In this work we show that iterative thresholding and K-means (ITKM) algorithms can recover a generating dictionary with K atoms from noisy $S$ sparse signals up to an error $\tilde \varepsilon$ as long as the initialisation is within a convergence radius, that is up to a $\log K$ factor inversely proportional to the dynamic range of the signals, and the sample size is proportional to $K \log K \tilde \varepsilon^{-2}$. The results are valid for arbitrary target errors if the sparsity level is of the order of the square root of the signal dimension $d$ and for target errors down to $K^{-\ell}$ if $S$ scales as $S \leq d/(\ell \log K)$.

In this work we show that iterative thresholding and K-means (ITKM) algorithms can recover a generating dictionary with K atoms from noisy $S$ sparse signals up to an error $\tilde \varepsilon$ as long as the initialisation is within a convergence radius, that is up to a $\log K$ factor inversely proportional to the dynamic range of the signals, and the sample size is proportional to $K \log K \tilde \varepsilon^{-2}$. The results are valid for arbitrary target errors if the sparsity level is of the order of the square root of the signal dimension $d$ and for target errors down to $K^{-\ell}$ if $S$ scales as $S \leq d/(\ell \log K)$.

We introduce a new weighted averaging scheme using "Fenchel-type" operators to recover primal solutions in the alternating minimization-type algorithm (AMA) for prototype constrained convex optimization. Our approach combines the classical AMA idea in \cite{Tseng1991} and Nesterov's prox-function smoothing technique without requiring the strong convexity of the objective function. We develop a new non-accelerated primal-dual AMA method and estimate its primal convergence rate both on the objective residual and on the feasibility gap. Then, we incorporate Nesterov's accelerated step into this algorithm and obtain a new accelerated primal-dual AMA variant endowed with a rigorous convergence rate guarantee. We show that the worst-case iteration-complexity in this algorithm is optimal (in the sense of first-oder black-box models), without imposing the full strong convexity assumption on the objective.

This paper determines upper bounds on the expected time complexity for a variety of known parallel algorithms for graph problems. For connectivity of both undirected and directed graphs, transitive closure and all pairs minimum cost paths, we prove the expected time is O(loglog n) for a parallel RAM model (RP-RAM) which allows random resolution of write conflicts, and expected time O(log n loglog n) for the P-RAM of (Wyllie, 79), which allows no write conflicts. We show that the expected parallel time for biconnected components and minimum spanning trees is O(loglog n)(2) for the RP-RAM and O(log n. (loglog n) (2)) for the P-RAM. Also we show that the problem of random graph isomorphism has expected parallel time O(loglog n) and O(log n) for the above parallel models, respectively. Our results also improve known upper bounds on the expected space required tor sequential graph algorithms. For example, we show that the problems of finding strong components, transitive closure and minimum cost paths have expected sequential space O(log-loglog n) with n (O)(1) time on a Turing Machine given random graphs as inputs.

This project considers attack and defense problems on networks with respect to WMD attacks. It provides novel optimization models and solutions for network vulnerability assessment and defense measurement in the face of cascading failures and dynamic attacks. The critical infrastructures considered are complex systems which consist of multiple dynamic independent networks interacting to each other. The attacks we considered are dynamic, that is, another attack may be launched during the recovery.

Typestate systems ensure many desirable properties of imperative programs, including initialization of object fields and correct use of stateful library interfaces. Abstract sets with cardinality constraints naturally generalize typestate properties: relationships between the typestates of objects can be expressed as subset and disjointness relations on sets, and elements of sets can be represented as sets of cardinality one. Motivated by these applications, this paper presents new algorithms and new complexity results for constraints on sets and their cardinalities. We study several classes of constraints and demonstrate a trade-off between their expressive power and their complexity. Our first result concerns a quantifier-free fragment of Boolean Algebra with Presburger Arithmetic. We give a nondeterministic polynomial-time algorithm for reducing the satisfiability of sets with symbolic cardinalities to constraints on constant cardinalities, and give a polynomial-space algorithm for the resulting problem. In a quest for more efficient fragments, we identify several subclasses of sets with cardinality constraints whose satisfiability is NP-hard. Finally, we identify a class of constraints that has polynomial-time satisfiability and entailment problems and can serve as a foundation for efficient program analysis.