Compressive Sensing (CS) theory states that real-world signals can often be recovered from much fewer measurements than those suggested by the Shannon sampling theorem. Nevertheless, recoverability does not only depend on the signal, but also on the measurement scheme. The measurement matrix should behave as close as possible to an isometry for the signals of interest. Therefore the search for optimal CS measurement matrices of size @math translates into the search for a set of @math @math -dimensional vectors with minimal coherence. Best Complex Antipodal Spherical Codes (BCASCs) are known to be optimal in terms of coherence. An iterative algorithm for BCASC generation has been recently proposed that tightly approaches the theoretical lower bound on coherence. Unfortunately, the complexity of each iteration depends quadratically on @math and @math . In this work we propose a modification of the algorithm that allows reducing the quadratic complexity to linear on both @math and @math . Numerical evaluation showed that the proposed approach does not worsen the coherence of the resulting BCASCs. On the contrary, an improvement was observed for large @math . The reduction of the computational complexity paves the way for using the BCASCs as CS measurement matrices in problems with large @math . We evaluate the CS performance of the BCASCs for recovering sparse signals. The BCASCs are shown to outperform both complex random matrices and Fourier ensembles as CS measurement matrices, both in terms of coherence and sparse recovery performance, especially for low @math , which is the case of interest in CS.
In this section we provide a general comparison between the ANN-BCASC approximation and other approaches for generating close-to-optimal complex codes. In order to provide a complete cumulative comparison, the best option for such comparison is to extend the tables in @cite_15 , which are in turn an extension of Table II of @cite_39 and Table II of @cite_77 , respectively. These tables provide the values of coherence obtained from complex SCs generated using different methods and are named Table and Table , homonimously to the corresponding tables in @cite_15 . For both the BCASC and the ANN-BCASC methods we adopt the best result of ten independent runs. We also measure the time that each algorithm needed to generate the codes. For the other algorithms, we preserve the values in the original tables of @cite_15 . We use the reference BCASC algorithm with approximate summation with @math summands, in order to have a fair reference for the ANN-BCASC algorithm, for which we adopt the same @math and a constant @math for all cases considered. As in @cite_15 , for both methods @math and @math were used.
@cite_77 @cite_15 @cite_39
2169273233 1982831910 2010260400 2567804199
Vector sets with optimal coherence according to the Welch bound cannot exist for all pairs of dimension and cardinality. If such an optimal vector set exists, it is an equiangular tight frame and represents the solution to a Grassmannian line packing problem. Best Complex Antipodal Spherical Codes (BCASCs) are the best vector sets with respect to the coherence. By extending methods used to find best spherical codes in the real-valued Euclidean space, the proposed approach aims to find BCASCs, and thereby, a complex-valued vector set with minimal coherence. There are many applications demanding vector sets with low coherence. Examples are not limited to several techniques in wireless communication or to the field of compressed sensing. Within this contribution, existing analytical and numerical approaches for coherence optimization of complex-valued vector spaces are summarized and compared to the proposed approach. The numerically obtained coherence values improve previously reported results. The drawback of increased computational effort is addressed and a faster approximation is proposed which may be an alternative for time critical cases. In this paper, we consider conic programming problems whose constraints consist of linear equalities, linear inequalities, a nonpolyhedral cone, and a polyhedral cone. A convenient way for solving this class of problems is to apply the directly extended alternating direction method of multipliers (ADMM) to its dual problem, which has been observed to perform well in numerical computations but may diverge in theory. Ideally, one should find a convergent variant which is at least as efficient as the directly extended ADMM in practice. We achieve this goal by designing a convergent semiproximal ADMM (called sPADMM3c for convenience) for convex programming problems having three separable blocks in the objective function with the third part being linear. At each iteration, the proposed sPADMM3c takes one special block coordinate descent (BCD) cycle with the order @math , instead of the usual @math Gauss--Seidel BCD cycle used in the nonconvergent directly extended 3-block ADMM, for updating the variable blocks. Our numerical experiments demonstrate that the convergent method is at least 20 faster than the directly extended ADMM with unit step-length for the vast majority of about 550 large-scale doubly nonnegative semidefinite programming problems with linear equality and or inequality constraints. This confirms that at least for conic convex programming, one can design a convergent and efficient ADMM with a special BCD cycle of updating the variable blocks. The problems of finding shortest common supersequences (SCS) and longest common subsequences (LCS) are two well-known NP -hard problems that have applications in many areas including computational molecular biology, data compression, robot motion planning and scheduling, text editing, etc. A lot of fruitless effort has been spent in searching for good approximation algorithms for these problems. In this paper, we show that these problems are inherently hard to approximate in the worst case. In particular, we prove that (i) SCS does not have a polynomial time linear approximation algorithm, unless P = NP ; (ii) There exists a constant @math such that, if SCS has a polynomial time approximation algorithm with ratio @math , where @math is the number of input sequences, then NP is contained in DTIME @math ; (iii) There exists a constant @math such that, if LCS has a polynomial time approximation algorithm with performance ratio @math , then P = NP . The proofs utilize the recent results of [Proc. 23rd IEEE Symposium on Foundations of Computer Science, 1992, pp. 14-23] on the complexity of approximation problems. In the second part of the paper, we introduce a new method for analyzing the average-case performance of algorithms for sequences, based on Kolmogorov complexity. Despite the above nonapproximability results, we show that near optimal solutions for both SCS and LCS can be found on the average. More precisely, consider a fixed alphabet @math and suppose that the input sequences are generated randomly according to the uniform probability distribution and are of the same length @math . Moreover, assume that the number of input sequences is polynomial in @math . Then, there are simple greedy algorithms which approximate SCS and LCS with expected additive errors @math and @math for any @math , respectively. Incidentally, our analyses also provide tight upper and lower bounds on the expected LCS and SCS lengths for a set of random sequences, solving a generalization of another well-known open question on the expected LCS length for two random sequences [K. Alexander, The rate of convergence of the mean length of the longest common subsequence, 1992, manuscript],[V. Chvatal and D. Sankoff, J. Appl. Probab., 12 (1975), pp. 306-315], [D. Sankoff and J. Kruskall, eds., Time Warps, String Edits, and Macromolecules: The Theory and Practice of Sequence Comparison, Addison-Wesley, Reading, MA, 1983]. An important question in theoretical computer science is to determine the best possible running time for solving a problem at hand. For geometric optimization problems, we often understand their complexity on a rough scale, but not very well on a finer scale. One such example is the two-dimensional knapsack problem for squares. There is a polynomial time (1 + ϵ)-approximation algorithm for it (i.e., a PTAS) but the running time of this algorithm is triple exponential in 1 ϵ, i.e., Ω(n221 ϵ). A double or triple exponential dependence on 1 ϵ is inherent in how this and several other algorithms for other geometric problems work. In this paper, we present an EPTAS for knapsack for squares, i.e., a (1+ϵ)-approximation algorithm with a running time of Oϵ(1)·nO(1). In particular, the exponent of n in the running time does not depend on ϵ at all! Since there can be no FPTAS for the problem (unless P = NP) this is the best kind of approximation scheme we can hope for. To achieve this improvement, we introduce two new key ideas: We present a fast method to guess the Ω(221 ϵ) relatively large squares of a suitable near-optimal packing instead of using brute-force enumeration. Secondly, we introduce an indirect guessing framework to define sizes of cells for the remaining squares. In the previous PTAS each of these steps needs a running time of Ω(n221 ϵ) and we improve both to Oϵ(1) · nO(1). We complete our result by giving an algorithm for two-dimensional knapsack for rectangles under (1 + ϵ)-resource augmentation. In this setting, we also improve the best known running time of Ω(n1 ϵ1 ϵ) to Oϵ(1) · nO(1) and compute even a solution with optimal profit, in contrast to the best previously known polynomial time algorithm for this setting that computes only an approximation. We believe that our new techniques have the potential to be useful for other settings as well.