Efficient Quantum Algorithms for (Gapped) Group Testing and Junta Testing

Longest common substring (LCS) is an important text processing problem, which has recently been investigated in the quantum query model. The decision version of this problem, LCS with threshold \(d\) , asks whether two length- \(n\) input strings have a common substring of length \(d\) . The two extreme cases, \(d=1\) and \(d=n\) , correspond, respectively to Element Distinctness and Unstructured Search, two fundamental problems in quantum query complexity. However, the intermediate case \(1\ll d\ll n\) was not fully understood. We show that the complexity of LCS with threshold \(d\) smoothly interpolates between the two extreme cases up to \(n^{o(1)}\) factors: — LCS with threshold \(d\) has a quantum algorithm in \(n^{2/3+o(1)}/d^{1/6}\) query complexity and time complexity, and requires at least \(\Omega(n^{2/3}/d^{1/6})\) quantum query complexity. Our result improves upon previous upper bounds \(\widetilde{O}(\min\{n/d^{1/2},n^{2/3}\})\) (Le Gall and Seddighin ITCS 2022, Akmal and Jin SODA 2022), and answers an open question of Akmal and Jin. Our main technical contribution is a quantum speed-up of the powerful String Synchronizing Set technique introduced by Kempa and Kociumaka (STOC 2019). It consistently samples \(n/\tau^{1-o(1)}\) synchronizing positions in the string depending on their length- \(\Theta(\tau)\) contexts, and each synchronizing position can be reported by a quantum algorithm in \(\widetilde{O}(\tau^{1/2+o(1)})\) time. Our quantum string synchronizing set also yields a near-optimal LCE data structure in the quantum setting. As another application of our quantum string synchronizing set, we study the \(k\) -mismatch Matching problem, which asks if the pattern has an occurrence in the text with at most \(k\) Hamming mismatches. Using a structural result of Charalampopoulos et al. (FOCS 2020), we obtain: — \(k\) -mismatch matching has a quantum algorithm with \(k^{3/4}n^{1/2+o(1)}\) query complexity and \(\widetilde{O}(kn^{1/2})\) time complexity. We also observe a non-matching quantum query lower bound of \(\Omega(\sqrt{kn})\) .

We investigate the query complexity of exact learning in the membership and (proper) equivalence query model. We give a complete characterization of concept classes that are learnable with a polynomial number of polynomial sized queries in this model. We give applications of this characterization, including results on learning a natural subclass of DNF formulas, and on learning with membership queries alone. Query complexity has previously been used to prove lower bounds on the time complexity of exact learning. We show a new relationship between query complexity and time complexity in exact learning: If any “honest” class is exactly and properly learnable with polynomial query complexity, but not learnable in polynomial time, then P = NP. In particular, we show that an honest class is exactly polynomial-query learnable if and only if it is learnable using an oracle for Γ p 4 .

This article initiates the study of testing properties of directed graphs. In particular, the article considers the most basic property of directed graphs--acyclicity. Because the choice of representation affects the choice of algorithm, the two main representations of graphs are studied. For the adjacency-matrix representation, most appropriate for dense graphs, a testing algorithm is developed that requires query and time complexity of O(1/e2), where e is a distance parameter independent of the size of the graph. The algorithm, which can probe the adjacency matrix of the graph, accepts every graph that is acyclic, and rejects, with probability at least 2/3, every graph whose adjacency matrix should be modified in at least e fraction of its entries so that it becomes acyclic. For the incidence list representation, most appropriate for sparse graphs, an Ω(|V|1/3) lower bound is proved on the number of queries and the time required for testing, where V is the set of vertices in the graph. Along with acyclicity, this article considers the property of strong connectivity. Contrasting upper and lower bounds are proved for the incidence list representation. In particular, if the testing algorithm can query on both incoming and outgoing edges at each vertex, then it is possible to test strong connectivity in O(1/e) time and query complexity. On the other hand, if the testing algorithm only has access to outgoing edges, then Ω(√N) queries are required to test for strong connectivity.

We consider the problem of testing graph cluster structure: given access to a graph G = (V, E), can we quickly determine whether the graph can be partitioned into a few clusters with good inner conductance, or is far from any such graph? This is a generalization of the well-studied problem of testing graph expansion, where one wants to distinguish between the graph having good expansion (i.e. being a good single cluster) and the graph having a sparse cut (i.e. being a union of at least two clusters). A recent work of Czumaj, Peng, and Sohler (STOC'15) gave an ingenious sublinear time algorithm for testing k-clusterability in time O(n^1/2 poly(k)). Their algorithm implicitly embeds a random sample of vertices of the graph into Euclidean space, and then clusters the samples based on estimates of Euclidean distances between the points. This yields a very efficient testing algorithm, but only works if the cluster structure is very strong: it is necessary to assume that the gap between conductances of accepted and rejected graphs is at least logarithmic in the size of the graph G. In this paper we show how one can leverage more refined geometric information, namely angles as opposed to distances, to obtain a sublinear time tester that works even when the gap is a sufficiently large constant. Our tester is based on the singular value decomposition of a natural matrix derived from random walk transition probabilities from a small sample of seed nodes. We complement our algorithm with a matching lower bound on the query complexity of testing clusterability. Our lower bound is based on a novel property testing problem, which we analyze using Fourier analytic tools. As a byproduct of our techniques, we also achieve new lower bounds for the problem of approximating MAX-CUT value in sublinear time.

The regularity lemma of Szemeredi turned out to be the most powerful tool for studying the testability of graph properties in the dense graph model. In fact, as we argue in this paper, this lemma can be used in order to prove (essentially) all the previous results in this area. More precisely, a barrier for obtaining an efficient testing algorithm for a graph property P was having an efficient regularity lemma for graphs satisfying P. The problem is that for many natural graph properties (e.g. triangle freeness) it is known that a graph can satisfy P and still only have regular partitions of tower-type size. This means that there was no viable path for obtaining reasonable bounds on the query complexity of testing such properties. In this paper we consider the property of being induced C_4-free, which also suffers from the fact that a graph might satisfy this property but still have only regular partitions of tower-type size. By developing a new approach for this problem we manage to overcome this barrier and thus obtain a merely exponential bound for testing this property. This is the first substantial progress on a problem raised by Alon in 2001, and more recently by Alon, Conlon and Fox. We thus obtain the first example of an efficient testing algorithm that cannot be derived from an efficient version of the regularity lemma.

We consider the question of whether adaptivity can improve the complexity of property testing algorithms in the dense graphs model. It is known that there can be at most a quadratic gap between adaptive and non-adaptive testers in this model, but it was not known whether any gap indeed exists. In this work we reveal such a gap.Specifically, we focus on the well studied property of bipartiteness. Bogdanov and Trevisan (IEEE Symposium on Computational Complexity, 2004) proved a lower bound of Ω(1/ε 2) on the query complexity of non-adaptive testing algorithms for bipartiteness. This lower bound holds for graphs with maximum degree O(εn). Our main result is an adaptive testing algorithm for bipartiteness of graphs with maximum degree O(εn) whose query complexity is \(\tilde{O}(1/\epsilon^{3/2})\). A slightly modified version of our algorithm can be used to test the combined property of being bipartite and having maximum degree O(εn). Thus we demonstrate that adaptive testers are stronger than non-adaptive testers in the dense graphs model.We note that the upper bound we obtain is tight up-to polylogarithmic factors, in view of the Ω(1/ε 3/2) lower bound of Bogdanov and Trevisan for adaptive testers. In addition we show that \(\tilde{O}(1/\epsilon^{3/2})\) queries also suffice when (almost) all vertices have degree \(\Omega(\sqrt \epsilon \cdot n)\). In this case adaptivity is not necessary.KeywordsQuery ComplexityTesting AlgorithmAdaptive TesterDense GraphNeighbor QueryThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

Planarity, bipartiteness and (directed) acyclicity are basic graph properties with classic linear time recognition algorithms. However, the problems of testing whether a given (di)graph has k vertices whose deletion makes it planar, bipartite or a directed acyclic graph (DAG) are all fundamental NP-complete problems when k is part of the input. As a result, a significant amount of research has been devoted to understanding whether, for every fixed k, these problems admit a polynomial time algorithm (where the exponent in the polynomial is independent of k) and in particular, whether they admit linear time algorithms. While we now know that for any fixed k, we can test in linear time whether a graph is k vertices away from being planar [FOCS 2009, SODA 2014] or bipartite [SODA 2014, SICOMP 2016], the best known algorithms in the case of directed acyclicity are the algorithm of Garey and Tarjan [IPL 78] which runs in time O(nk–1m) and the algorithm of Chen, Liu, Lu, O'Sullivan and Razgon [JACM 2008] which runs in time O(k!4kk4nm). In other words, it has remained open whether it is possible to recognize in linear time, a graph which is 2 vertices away from being acyclic! In this paper, we settle this question by giving an algorithm that decides whether a given graph is k vertices away from being acyclic, in time O(k!4kk5(n + m)). That is, for every fixed k, our algorithm runs in time O(m + n), thus mirroring the case for planarity and bipartiteness. Our algorithm is designed via a general methodology that shaves off a factor of n from some algorithms that use the powerful technique of iterative compression. The two main features of our methodology are: (i) This is the first generic technique for designing linear time algorithms for directed cut-problems and (ii) it can be used in combination with future improvements in algorithms for the compression version of other well-studied cut-problems such as Multicut and Directed Subset Feedback Vertex Set.

Lattice-based cryptography has recently emerged as a prime candidate for efficient and secure post-quantum cryptography. The two main hard problems underlying its security are the shortest vector problem (SVP) and the closest vector problem (CVP). Various algorithms have been studied for solving these problems, and for SVP, lattice sieving currently dominates in terms of the asymptotic time complexity: one can heuristically solve SVP in time $2^{0.292d}$ in high dimensions $d$ [BDGL'16]. Although several SVP algorithms can also be used to solve CVP, it is not clear whether this also holds for heuristic lattice sieving methods. The best time complexity for CVP is currently $2^{0.377d}$ [BGJ'14]. In this paper we revisit sieving algorithms for solving SVP, and study how these algorithms can be modified to solve CVP and its variants as well. Our first method is aimed at solving one problem instance and minimizes the overall time complexity for a single CVP instance with a time complexity of $2^{0.292d}$. Our second method minimizes the amortized time complexity for several instances on the same lattice, at the cost of a larger preprocessing cost. We can solve the closest vector problem with preprocessing (CVPP) with $2^{0.636d}$ space and preprocessing, in $2^{0.136d}$ time, while the query complexity can even be reduced to $2^{\epsilon d}$ at the cost of preprocessing time and memory complexities of $(1/\epsilon)^{O(d)}$. For easier variants of CVP, such as approximate CVP and bounded distance decoding (BDD), we further show how the preprocessing method achieves even better complexities. For instance, we can solve approximate CVPP with large approximation factors $k$ with polynomial-sized advice in polynomial time if $k = \Omega(\sqrt{d/\log d})$, heuristically closing the gap between the decision-CVPP result of [AR'04] and the search-CVPP result of [DRS'14].

We consider the problem of distribution-free testing of the class of monotone monomials and the class of monomials over n variables.0 While there are very efficient algorithms for testing a variety of functions classes when the underlying distribution is uniform, designing distribution-free algorithms (which must work under any arbitrary and unknown distribution), tends to be a more challenging task. When the underlying distribution is uniform, Parnas et al. (SIAM Journal on Discrete Math, 2002) give an algorithm for testing (monotone) monomials whose query complexity does not depends on n, and whose dependence on the distance parameter is (inverse) linear. In contrast, Glasner and Servedio (in Proceedings of RANDOM, 2007) prove that every distribution-free testing algorithm for monotone monomials as well as for general monomials must have query complexity Ω(n1/5) (for a constant distance parameter e). In this paper we present distribution-free testing algorithms for these classes where the query complexity of the algorithms is O(n1/2/e). We note that as opposed to previous results for distribution-free testing, our algorithms do not build on the algorithms that work under the uniform distribution. Rather, we define and exploit certain structural properties of monomials (and functions that differ from them in a nonnegligible manner), which were not used in previous work on property testing.

Spin Transfer Torque Magnetic Random Access Memory (STT-MRAM) is a promising alternative technology for on-chip memories due to several advantages such as high density, non-volatility, scalability, high endurance and CMOS compatibility. Due to the emerging fabrication processes of magnetic layers in the fabrication of STTMRAM devices, they are more susceptible to manufacturing defects and have different failure mechanisms compared to conventional CMOS memories. This mandates specific fault modeling and development of proper test algorithms for high coverage testing of these memories in order to ensure correct functionality in the field. In this paper, a detailed defect injection is performed based on the magnetic devices and layout characteristics of STT-MRAM and unique fault models are constructed for these memories. Based on the derived fault models and behaviors, efficient test algorithms are developed to fully cover these faults.

The computational complexity study of algorithms is highly germane to the design and development of high-speed computing devices. The whole essence of computation is principally influenced by efficiency of algorithms; this is more so the case with the algorithms whose solution space explodes exponentially. Cryptographic algorithms are good examples of such algorithms. The goal of this study is to compare the computational speeds of RSA and ElGamal cryptographic algorithms by carrying out a survey of works done so far by researchers. This study has therefore examined some of the results of the studies already done and highlighted which of the RSA and ElGamal algorithms performed better under given parameters. It is expected that this study would spur further investigation of the behaviour of cryptographic structures in order to ascertain their complexity and impact on the field of theoretical computer science. The experimental results of many of the papers reviewed showed that RSA cryptographic algorithm performs better as regards to energy usage, time complexity and space complexity of text, image and audio data during encryption process while some studies showed that ElGamal performs better in terms of time complexity during decryption process.

We initiate the systematic study of the energy complexity of algorithms (in addition to time and space complexity) based on Landauer's Principle in physics, which gives a lower bound on the amount of energy a system must dissipate if it destroys information. We propose energy-aware variations of three standard models of computation: circuit RAM, word RAM, and transdichotomous RAM. On top of these models, we build familiar high-level primitives such as control logic, memory allocation, and garbage collection with zero energy complexity and only constant-factor overheads in space and time complexity, enabling simple expression of energy-efficient algorithms. We analyze several classic algorithms in our models and develop low-energy variations: comparison sort, insertion sort, counting sort, breadth-first search, Bellman-Ford, Floyd-Warshall, matrix all-pairs shortest paths, AVL trees, binary heaps, and dynamic arrays. We explore the time/space/energy trade-off and develop several general techniques for analyzing algorithms and reducing their energy complexity. These results lay a theoretical foundation for a new field of semi-reversible computing and provide a new framework for the investigation of algorithms.

We understand selection by intersection as distinguishing a single element of a set by the uniqueness of its occurrence in some other set. More precisely, given two sets A and B, if A ∩ B = {z}, then element z∈ A is selected by set B. Selectors are such families \(\mathcal{S}\) of sets B of some domain that allow to select many elements from sufficiently small subsets A of the domain. Selectors are used in communication protocols for the multiple-access channel, in implementations of distributed-computing primitives in radio networks, and in algorithms for group testing. We give new explicit (n,k,r)-selectors of size \(\mathcal{O}(min [n, \frac{k^2}{k-r+1} polylog~n])\), for any parameters r ≤ k ≤ n. We establish a lower bound \(\Omega(min [n, \frac{k^2}{k-r+1} \cdot \frac{log(n/k)}{log(k/(k-r+1))}])\) on the length of (n,k,r)-selectors, which demonstrates that our construction is within a polylog n factor close to optimal. The new selectors are applied to develop explicit implementations of selection resolution on the multiple-access channel, gossiping in radio networks and an algorithm for group testing with inhibitors.KeywordsRadio NetworkCollision DetectionLocal ClockBinary ArrayCombinatorial Group TestThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

This paper reconsidered the Two-Dimensional Bin Packing Problem from the perspective of practical application based on actual needs of small furniture companies in China. Although there have been many researches on this problem for many years, most of the existed researches put their foremost attention on developing an algorithm with low complexity or approximately best performance which means that it can nearly work out the best solution most of the time. This is the common situation when we do research on such problems, but unfortunately it will leave out abundant practical needs. For example, the computational resources of those small companies are seldom, which makes it impossible to use algorithms that almost gets the best solution but takes much time. The significant goal is to find out a solution satisfactory enough within a short time, so some complex algorithms which aim to get a nearly best result aren’t suitable here. Meanwhile, the cutting times are also a rather critical matter for them. Cutting too many times will cause high wastage to machines and is therefore unaffordable for small companies, but this was often ignored in previous researches especially in classic meta-heuristic algorithms since they frequently lead to complicated packing patterns with massive cutting times. This paper reviewed previous related researches and summarized their shortages and some necessary characteristics of a practically efficient algorithm. Based on classic algorithms, it gained a two-stage heuristic algorithm which performed better than current used ones in those small companies, as well as meets their special needs stated in this paper which is a rather important issue. And this algorithm itself may be used to meet needs of those factories or be used as a starter of the further optimization search.

The classic buffer insertion algorithm of van Ginneken has time and space complexity O(n/sup 2/), where n is the number of possible buffer positions. For more than a decade, van Ginneken's algorithm has been the foundation of buffer insertion. In this paper, we present a new algorithm that computes the same optimal buffer insertion, but runs much faster. For 2-pin nets, our time complexity is O(nlogn) and space complexity is O(n). For multipin nets, our time complexity is O(nlog/sup 2/n) and space complexity is O(nlogn). The speedup is achieved by four novel techniques: predictive pruning, candidate tree, fast redundancy check, and fast merging. On industrial test cases, the new algorithms is 2-80 times faster than van Ginneken's algorithm and uses 1/4-1/500 of the memory. Since van Ginneken's algorithm and its variations are used by most existing algorithms on buffer insertion and buffer sizing, our new algorithm significantly improves the performance of all these algorithms. The predictive pruning technique has been applied to buffer cost minimization (Shi et al., 2004), and significantly improved the running time.