Complexities for generalized models of self-assembly

Locally Checkable Labeling (LCL) problems include essentially all the classic problems of LOCAL distributed algorithms. In a recent enlightening revelation, Chang and Pettie [FOCS'17] showed that any LCL (on bounded degree graphs) that has an o(log n)-round randomized algorithm can be solved in T_(LLL)(n) rounds, which is the randomized complexity of solving (a relaxed variant of) the Lovasz Local Lemma (LLL) on bounded degree n-node graphs. Currently, the best known upper bound on T_(LLL)(n) is O(log n), by Chung, Pettie, and Su [PODC'14], while the best known lower bound is Omega(log log n), by Brandt et al. [STOC'16]. Chang and Pettie conjectured that there should be an O(log log n)-round algorithm (on bounded degree graphs). Making the first step of progress towards this conjecture, and providing a significant improvement on the algorithm of Chung et al. [PODC'14], we prove that T_(LLL)(n)= 2^O(sqrt(log log n)). Thus, any o(log n)-round randomized distributed algorithm for any LCL problem on bounded degree graphs can be automatically sped up to run in 2^O(sqrt(log log n)) rounds. Using this improvement and a number of other ideas, we also improve the complexity of a number of graph coloring problems (in arbitrary degree graphs) from the O(log n)-round results of Chung, Pettie and Su [PODC'14] to 2^O(sqrt(log log n)). These problems include defective coloring, frugal coloring, and list vertex-coloring.

We present a deterministic fully-dynamic data structure for maintaining information about the bridges in a graph. We support updates in O((log n)2) amortized time, and can find a bridge in the component of any given vertex, or a bridge separating any two given vertices, in O(log n/ log log n) worst case time. Our bounds match the current best for bounds for deterministic fully-dynamic connectivity up to log log n factors. The previous best dynamic bridge finding was an O((log n)3) amortized time algorithm by Thorup [STOC2000], which was a bittrick-based improvement on the O((log n)4) amortized time algorithm by Holm et al.[STOC98, JACM2001]. Our approach is based on a different and purely combinatorial improvement of the algorithim of Holm et al., which by itself gives a new combinatorial O((log n)3) amortized time algorithm. Combining it with Thorup's bittrick, we get down to the claimed O((log n)2) amortized time. Essentially the same new trick can be applied to the biconnectivity data structure from [STOC98, JACM2001], improving the amortized update time to O((log n)3). We also offer improvements in space. We describe a general trick which applies to both of our new algorithms, and to the old ones, to get down to linear space, where the previous best use O(m + n log n log log n). Our result yields an improved running time for deciding whether a unique perfect matching exists in a static graph.

This thesis addresses the computational notion of aesthetics in the framework of multistate two-dimensional cellular automata (2D CA). The measure of complexity is a core concept in computational approaches to aesthetics. Shannon's information theory provided an objective measure of complexity, which led to the emergence of various informational theories of aesthetics. However, entropy fails to take into account the spatial characteristics of 2D patterns; these characteristics are fundamental in addressing the aesthetic problem, in general, and of CA-generated patterns, in particular. This thesis proposes two empirically evaluated alternative measures of complexity, taking into account the spatial characteristics of 2D patterns and experimental studies on human aesthetic perception in the visual domain. The measures are extended to robustly quantify the complexity of multi-state 2D CA-generated patterns. The first model, spatial complexity, is based on the probabilistic spatial distribution of homogeneous/heterogeneous neighbouring cells over the lattice of a multi-state 2D cellular automaton. The second model is based on algorithmic information theory (Kolmogorov complexity) which is extended to estimate the complexity of 2D patterns. The spatial complexity measure presents performance advantage over information-theoretic models, specifically in discriminating symmetries and the orientation in CA-generated patterns, enabling more accurate measurement of complexity in relation to aesthetic evaluations of 2D patterns. A series of experimental stimuli with various structural characteristics and levels of complexity were generated by seeding 3-state 2D CA with different initial configurations for psychological experiments. The results of experimentation demonstrate the presence of correlation between spatial complexity measures and aesthetic judgements of experimental stimuli. The same results were obtained for the estimations of Kolmogorov complexity of experimental stimuli.

OF THE DISSERTATION Random matrices and random boxes by Linh V. Tran Dissertation Director: Prof. Van Vu This thesis concerns two questions on random structures: the semi-circular law for adjacency matrix of regular random graph and the piercing number for random boxes. • Random matrices We proved in full generality the semi-circular law for random d-regular graph model in the case d tends to infinity as n does. Our result complements the McKay law [19], which applied for the case d is an absolute constant. • Random boxes. Take n random boxes with axis-parallel edges inside the unit cube [0, 1]d, the piercing number τd(n) is the minimum number of points needed to pierce all boxes. Using hypergraph setting, we was able to prove a near sharp estimation for τd(n): for any d ≥ 2 Ωd( √ n(log n)d/2−1) = τd(n) = Od( √ n(log n)d/2−1 log log n). This thesis is based on two papers by the author [31] and [30] (joint work with Van Vu and Ke Wang).

In the range emptiness searching problem, we are given a set P of n points in Rd, and wish to preprocess them into a data structure that supports efficient range emptiness queries, in which we specify a range σ, which is a semi-algebraic set in Rd of some fixed kind, and wish to determine whether P ∩ σ = θ. Range emptiness searching arises in many applications, and has been treated by Matousek [15] in the special case where the ranges are halfspaces bounded by hyperplanes. In this paper we extend the analysis to the general semi-algebraic case, and show how to adapt Matousek's technique to this case, without the need to linearize the ranges into a higher-dimensional space. This yields more efficient solutions to several interesting problems, and we demonstrate the new technique in two applications:(i) An algorithm for ray shooting amid balls in R3, which uses O* (n) storage and preprocessing, and answers a query in O* (n2/3) time, improving the previous bound of O* (n3/47).(ii) An algorithm that preprocesses, in O*(n) time, a set P of n points in R3 into a data structure with O*(n) storage, so that, for any query line l or segment e, the point of P farthest from l or from e can be computed in O* (n1/2) time.Our technique is closely related to the notions of nearest- or farthest-neighbor generalized Voronoi diagrams, and of the union or intersection of geometric objects, where sharper bounds on the combinatorial complexity of these structures yield faster range emptiness searching algorithms. For example, in the case of ray shooting amid balls, the structure that arises in our algorithm is the Euclidean Voronoi diagram of lines in 3-space, and the performance of the algorithm depends on the complexity of such diagrams (for which tight bounds are still unknown).

In this paper the precise asymptotic in the law of the iterated logarithm is considered. The result of A. Gut and A. Spataru [Ann. Probab., 28 (2000), pp. 1870–1883] is generalized for the case of the variables not of the same distribution.

The area of parameterized approximation seeks to combine approximation and parameterized algorithms to obtain, e.g., (1+epsilon)-approximations in f(k,epsilon)n^O(1) time where k is some parameter of the input. The goal is to overcome lower bounds from either of the areas. We obtain the following results on parameterized approximability: - In the maximum independent set of rectangles problem (MISR) we are given a collection of n axis parallel rectangles in the plane. Our goal is to select a maximum-cardinality subset of pairwise non-overlapping rectangles. This problem is NP-hard and also W[1]-hard [Marx, ESA'05]. The best-known polynomial-time approximation factor is O(log log n) [Chalermsook and Chuzhoy, SODA'09] and it admits a QPTAS [Adamaszek and Wiese, FOCS'13; Chuzhoy and Ene, FOCS'16]. Here we present a parameterized approximation scheme (PAS) for MISR, i.e. an algorithm that, for any given constant epsilon>0 and integer k>0, in time f(k,epsilon)n^g(epsilon), either outputs a solution of size at least k/(1+epsilon), or declares that the optimum solution has size less than k. - In the (2-dimensional) geometric knapsack problem (2DK) we are given an axis-aligned square knapsack and a collection of axis-aligned rectangles in the plane (items). Our goal is to translate a maximum cardinality subset of items into the knapsack so that the selected items do not overlap. In the version of 2DK with rotations (2DKR), we are allowed to rotate items by 90 degrees. Both variants are NP-hard, and the best-known polynomial-time approximation factor is 2+epsilon [Jansen and Zhang, SODA'04]. These problems admit a QPTAS for polynomially bounded item sizes [Adamaszek and Wiese, SODA'15]. We show that both variants are W[1]-hard. Furthermore, we present a PAS for 2DKR. For all considered problems, getting time f(k,epsilon)n^O(1), rather than f(k,epsilon)n^g(epsilon), would give FPT time f'(k)n^O(1) exact algorithms by setting epsilon=1/(k+1), contradicting W[1]-hardness. Instead, for each fixed epsilon>0, our PASs give (1+epsilon)-approximate solutions in FPT time. For both MISR and 2DKR our techniques also give rise to preprocessing algorithms that take n^g(epsilon) time and return a subset of at most k^g(epsilon) rectangles/items that contains a solution of size at least k/(1+epsilon) if a solution of size k exists. This is a special case of the recently introduced notion of a polynomial-size approximate kernelization scheme [Lokshtanov et al., STOC'17].

A new version of stochastic complexity for a parametric statistical model is derived, based on a class of two-part codes. We show that choosing the quantization in the first step according to the Fisher information is optimal and we compare our approach to a recent result of Rissanen (1983). An application to robust regression model selection is presented.

We consider computing a longest palindrome in the streaming model, where the symbols arrive one-by-one and we do not have random access to the input. While computing the answer exactly using sublinear space is not possible in such a setting, one can still hope for a good approximation guarantee. Our contribution is twofold. First, we provide lower bounds on the space requirements for randomized approximation algorithms processing inputs of length n. We rule out Las Vegas algorithms, as they cannot achieve sublinear space complexity. For Monte Carlo algorithms, we prove a lower bounds of Omega(M log min {|Sigma|, M}) bits of memory; here M=n/E for approximating the answer with additive error E, and M= log n / log (1 + epsilon) for approximating the answer with multiplicative error (1 + epsilon). Second, we design three real-time algorithms for this problem. Our Monte Carlo approximation algorithms for both additive and multiplicative versions of the problem use O(M) words of memory. Thus the obtained lower bounds are asymptotically tight up to a logarithmic factor. The third algorithm is deterministic and finds a longest palindrome exactly if it is short. This algorithm can be run in parallel with a Monte Carlo algorithm to obtain better results in practice. Overall, both the time and space complexity of finding a longest palindrome in a stream are essentially settled.

We initiate the study of the computational complexity of the covering radius problem for point lattices, and approximation versions of the problem for both lattices and linear codes. We also investigate the computational complexity of the shortest linearly independent vectors problem, and its relation to the covering radius problem for lattices. For the covering radius on n-dimensional lattices, we show that the problem can be approximated within any constant factor /spl gamma/(n) > 1 in random exponential time 2/sup O(n)/, it is in AM for /spl gamma/(n) = 2, in coAM for /spl gamma/(n) = /spl radic/(n log n), and in NP /spl cap/ coNP for /spl gamma/(n) = /spl radic/n. For the covering radius on n-dimensional linear codes, we show that the problem can be solved in deterministic polynomial time for approximation factor /spl gamma/(n) = log n, but cannot be solved in polynomial time for some /spl gamma/(n) = /spl Omega/(log log n) unless NP can be simulated in deterministic n/sup O(log log log n)/ time. Moreover, we prove that the problem is NP-hard for every constant approximation factor, it is /spl Pi//sub 2/-hard for some constant approximation factor, and it is in AM for approximation factor 2. So, it is unlikely to be /spl Pi//sub 2/-hard for approximation factors larger than 2. This is a natural hardness of approximation result in the polynomial hierarchy. For the shortest independent vectors problem, we give a coAM protocol achieving approximation factor /spl gamma/(n) = /spl radic/(n/log n), solving an open problem of Blomer and Seifert (1999), and prove that the problem is also in coNP for /spl gamma/(n) = /spl radic/n. Both results are obtained by giving a gap-preserving nondeterministic polynomial time reduction to the closest vector problem.

Algorithms for Computing Motorcycle Graphs Lie Yan We present a new algorithm for computing motorcycle graphs that runs inO(n) time for any e > 0, improving on all previously known algorithms. If the motorcycles follow only C different directions, our algorithm can be made to run in O(Cn log n) time. The main application of this result is to computing the straight skeleton of a polygon. It allows us to compute the straight skeleton of a non-degenerate polygon with h holes in O(n √ h+ 1 log n+n) expected time. If all input coordinates are O(log n)-bit rational numbers, we can compute the straight skeleton of a (possibly degenerate) polygon with h holes in O(n √ h+ 1 log n) expected time. In particular, it means that we can compute the straight skeleton of a simple polygon in O(n log n) expected time if all input coordinates areO(log n)-bit rationals, while all previously known algorithms have worst-case running time ω(n).

In the Uncapacitated Facility Location (UFL) problem, there is a fixed cost for opening a facility, and some distance matrix d that determines the cost of distributing commodities from any facility i to any consumer j. The problem is NP-hard in general and when d consists of a distance metric in a graph [7, 12]. However, for the case where the commodity transportation costs are given by path lengths in a tree, an O(n2) dynamic programming algorithm was given by [4, 7]. We improve this dynamic programming algorithm by using the geometry of piecewise linear functions and fast merging of the binary search trees used to store these functions. We achieve the complexity bound of O(n log n) for the Tree Location Problem and some related problems. Our approach gives a general method for solving tree dynamic programming problems.

We describe an asymptotically optimal data-structure for dynamic point location for horizontal segments. For n line-segments, queries take O(log n) time, updates take O(log n) amortized time and the data structure uses O(n) space. This is the first structure for the problem that is optimal in space and time (modulo the possibility of removing amortization). We also describe dynamic data structures for orthogonal range reporting and orthogonal intersection reporting. In both data structures for n points (segments) updates take O(log n) amortized time, queries take O(log n+k log n/log log n) time, and the structures use O(n) space, where k is the size of the output. The model of computation is the unit cost RAM.

A quasi-Gray code of dimension n and length l over an alphabet Sigma is a sequence of distinct words w_1,w_2,...,w_l from Sigma^n such that any two consecutive words differ in at most c coordinates, for some fixed constant c>0. In this paper we are interested in the read and write complexity of quasi-Gray codes in the bit-probe model, where we measure the number of symbols read and written in order to transform any word w_i into its successor w_{i+1}. We present construction of quasi-Gray codes of dimension n and length 3^n over the ternary alphabet {0,1,2} with worst-case read complexity O(log n) and write complexity 2. This generalizes to arbitrary odd-size alphabets. For the binary alphabet, we present quasi-Gray codes of dimension n and length at least 2^n - 20n with worst-case read complexity 6+log n and write complexity 2. This complements a recent result by Raskin [Raskin '17] who shows that any quasi-Gray code over binary alphabet of length 2^n has read complexity Omega(n). Our results significantly improve on previously known constructions and for the odd-size alphabets we break the Omega(n) worst-case barrier for space-optimal (non-redundant) quasi-Gray codes with constant number of writes. We obtain our results via a novel application of algebraic tools together with the principles of catalytic computation [Buhrman et al. '14, Ben-Or and Cleve '92, Barrington '89, Coppersmith and Grossman '75].

This paper presents preliminary results on a visual complexity study with maps where we attempt quantifying generalization quality using algorithmic visual complexity measures.