Jointly Optimal Time Segmentation, Component Selection and Quantization for Sinusoidal Coding of Audio and Speech

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].

Mobile phones can record individual’s daily behavioral data as a time-series. In this paper, we present an effective time-series segmentation technique that extracts optimal time segments of individual’s similar behavioral characteristics utilizing their mobile phone data. One of the determinants of an individual’s behavior is the various activities undertaken at various times-of-the-day and days-of-the-week. In many cases, such behavior will follow temporal patterns. Currently, researchers use either equal or unequal interval-based segmentation of time for mining mobile phone users’ behavior. Most of them take into account static temporal coverage of 24-h-a-day and few of them take into account the number of incidences in time-series data. However, such segmentations do not necessarily map to the patterns of individual user activity and subsequent behavior because of not taking into account the diverse behaviors of individuals over time-of-the-week. Therefore, we propose a behavior-oriented time segmentation (BOTS) technique that takes into account not only the temporal coverage of the week but also the number of incidences of diverse behaviors dynamically for producing similar behavioral time segments over the week utilizing time-series data. Experiments on the real mobile phone datasets show that our proposed segmentation technique better captures the user’s dominant behavior at various times-of-the-day and days-of-the-week enabling the generation of high confidence temporal rules in order to mine individual mobile phone users’ behavior.

Automatic passive data selection in time domain for imaging near-surface surface waves

We present the first polynomial time algorithm to learn nontrivial classes of languages of infinite trees. Specifically, our algorithm uses membership and equivalence queries to learn classes of omega-tree languages derived from weak regular omega-word languages in polynomial time. The method is a general polynomial time reduction of learning a class of derived omega-tree languages to learning the underlying class of omega-word languages, for any class of omega-word languages recognized by a deterministic Büchi acceptor. Our reduction, combined with the polynomial time learning algorithm of Maler and Pnueli [Maler and Pneuli, Inform. Comput., 1995] for the class of weak regular omega-word languages yields the main result. We also show that subset queries that return counterexamples can be implemented in polynomial time using subset queries that return no counterexamples for deterministic or non-deterministic finite word acceptors, and deterministic or non-deterministic Büchi omega-word acceptors. A previous claim of an algorithm to learn regular omega-trees due to Jayasrirani, Begam and Thomas [Jayasrirani et al., ICGI, 2008] is unfortunately incorrect, as shown in [Angluin, YALEU/DCS/TR-1528, 2016].

Gathering a group of mobile agents is a fundamental task in the field of distributed and mobile systems. This can be made drastically more difficult to achieve when some agents are subject to faults, especially the Byzantine ones that are known as being the worst faults to handle. In this paper we study, from a deterministic point of view, the task of Byzantine gathering in a network modeled as a graph. In other words, despite the presence of Byzantine agents, all the other (good) agents, starting from {possibly} different nodes and applying the same deterministic algorithm, have to meet at the same node in finite time and stop moving. An adversary chooses the initial nodes of the agents (the number of agents may be larger than the number of nodes) and assigns a different positive integer (called label) to each of them. Initially, each agent knows its label. The agents move in synchronous rounds and can communicate with each other only when located at the same node. Within the team, f of the agents are Byzantine. A Byzantine agent acts in an unpredictable and arbitrary way. For example, it can choose an arbitrary port when it moves, can convey arbitrary information to other agents and can change its label in every round, in particular by forging the label of another agent or by creating a completely new one. Besides its label, which corresponds to a local knowledge, an agent is assigned some global knowledge denoted by GK that is common to all agents. In literature, the Byzantine gathering problem has been analyzed in arbitrary n-node graphs by considering the scenario when GK=(n,f) and the scenario when GK=f. In the first (resp. second) scenario, it has been shown that the minimum number of good agents guaranteeing deterministic gathering of all of them is f+1 (resp. f+2). However, for both these scenarios, all the existing deterministic algorithms, whether or not they are optimal in terms of required number of good agents, have the major disadvantage of having a time complexity that is exponential in n and L, where L is the value of the largest label belonging to a good agent. In this paper, we seek to design a deterministic solution for Byzantine gathering that makes a concession on the proportion of Byzantine agents within the team, but that offers a significantly lower complexity. We also seek to use a global knowledge whose the length of the binary representation (that we also call size) is small. In this respect, assuming that the agents are in a strong team i.e., a team in which the number of good agents is at least some prescribed value that is quadratic in f, we give positive and negative results. On the positive side, we show an algorithm that solves Byzantine gathering with all strong teams in all graphs of size at most n, for any integers n and f, in a time polynomial in n and the length |l_{min}| of the binary representation of the smallest label of a good agent. The algorithm works using a global knowledge of size O(log log log n), which is of optimal order of magnitude in our context to reach a time complexity that is polynomial in n and |l_{min}|. Indeed, on the negative side, we show that there is no deterministic algorithm solving Byzantine gathering with all strong teams, in all graphs of size at most n, in a time polynomial in n and |l_{min}| and using a global knowledge of size o(log log log n).

A tournament T = (V , A) is a directed graph in which there is exactly one arc between every pair of distinct vertices. Given a digraph on n vertices and an integer parameter k, the Feedback Arc Set problem asks whether the given digraph has a set of k arcs whose removal results in an acyclic digraph. The Feedback Arc Set problem restricted to tournaments is known as the k-Feedback Arc Set in Tournaments (k-FAST) problem. In this paper we obtain a linear vertex kernel for k-FAST. That is, we give a polynomial time algorithm which given an input instance T to k-FAST obtains an equivalent instance T ′ on O(k) vertices. In fact, given any fixed ϵ > 0, the kernelized instance has at most (2 + ϵ)k vertices. Our result improves the previous known bound of O(k2 ) on the kernel size for k-FAST. Our kernelization algorithm solves the problem on a subclass of tournaments in polynomial time and uses a known polynomial time approximation scheme for k- FAST.

We explore an alternative Information Retrieval paradigm called Query-By-Multiple-Examples (QBME) where the information need is described not by a set of terms but by a set of documents. Intuitive ideas for QBME include using the centroid of these documents or the well-known Rocchio algorithm to construct the query vector. We consider this problem from the perspective of text classification, and find that a better query vector can be obtained through learning with Support Vector Machines (SVMs). For online queries, we show how SVMs can be learned from one-class examples in linear time. For offline queries, we show how SVMs can be learned from positive and unlabeled examples together in linear or polynomial time. The effectiveness and efficiency of the proposed approaches have been confirmed by our experiments on four real-world datasets.

The set ℓ Pol of complex numbers ζ , which can be approximated in a polynomial time cζ ·n k depending from the precision 2−n, is a field. The operations of the field can be approximated in a time<c · n 2 and better relative to the time one needs to approximate the operands ζ 1 ,ζ 2 with precision 2−n. In the case of addition and multiplication it can be done for |ζ 1 |, |ζ 2 |<a with a c depending from a and the constants in the running time of the polynomial time approximation of ζ 1,ζ 2, but in the case of division the constant depends additionally from |ζ | . The same holds for the ring of the polynomials ℓ Pol [x ] and the field of the rational functions f ∈ ℓ Pol (x ). The constant factor in the polynomial time bound of the approximation of f (ζ ) depend additionally from the distance of ζ from the singularities of f . The field ℓ Pol is algebraically closed. In the case that the polynomials have constant coefficients there exist algorithms to approximate the roots of the polynomials in a linear time with the Newton method if the roots are simple and an isolation of the roots is precomputed [Sch82]. But this precomputation needs much time [ESY06]. The best known algorithms to solve this problem need a time O (m 5(τ +logm )2), m the degree of the polynomial and τ the length of the binary representation of the coefficients. The problem with not constant coefficients has been attacked on base of bitstreams in [Eig08], [ESY06]. In [Eig08] on can find an excellent overview of the state of art. In the case the coefficients are not fixed constants but given by approximations the situation is much more complicated because the precomputation depends from the precision of the approximation. It is clear that in general the approximation of a root of a polynomial with coefficients, which cannot be approximated in a time O (n k ), cannot be done in this time. Ker-I Ko discusses the approximation problems on base of the unary representation of the numbers [Ko91]. Polynomial time algorithms relative to dyadic and unary representation are obviously not the same. The motivation of this paper is the question how far the mentioned problems can be solved by global polynomial time algorithms. This are algorithms with a running time <c·n k with the constant c only depending from the constants of the polynomial time approximations of the arguments and the domain of the function to be computed. We prove that there exist analytic functions, which are computable on all finite domains in this sense and that analytic functions for which this is true can be represented by a power series in z.

Given a graph G=(V,E) with node weight w:V→R+ and a subset S⊆V, find a minimum total weight tree interconnecting all nodes in S. This is the node-weighted Steiner tree problem which will be studied in this paper. In general, this problem is NP-hard and cannot be approximated by a polynomial time algorithm with performance ratio aln n for any 0<a<1 unless NP⊆DTIME(nO(log n)), where n is the number of nodes in s. In this paper, we are the first to show that even though for unit disk graphs, the problem is still NP-hard and it has a polynomial time constant approximation. We present a 2.5ρ-approximation where ρ is the best known performance ratio for polynomial time approximation of classical Steiner minimum tree problem in graphs. As a corollary, we obtain that there is a polynomial time (9.875+e)-approximation algorithm for minimum weight connected dominating set in unit disk graphs, and also there is a polynomial time (4.875+e)-approximation algorithm for minimum weight connected vertex cover in unit disk graphs.

Makespan Parallel Machine and Flow Shop Scheduling belong to the core of the polynomial optimization problems. Both problems are well studied and they are known to be NP-hard, thus no optimal polynomial time algorithm exists under certain theoretical assumptions. In this paper we present a Polynomial Time Approximation Scheme for the generalized Min-Max version of the problems and the Competitive Ratio Approximation Scheme for the online counterpart of considered problems. All the presented algorithms work in linear time in the input size.

Ensuring the functional correctness of a digital system is achievable through formal verification. Despite the increased complexity of modern systems, formal verification still needs to be done in a reasonable time. Hence, Polynomial Formal Verification (PFV) techniques are being explored, as they provide guaranteed polynomial upper bounds on the time and space required for the verification process. Recently, it was shown that circuits characterized by a constant cutwidth can be verified in linear time using Answer Set Programming (ASP). However, these results are limited to combinational circuits, whereas most designs used in digital systems are sequential. In this paper, we introduce Linear Formal Verification (LFV) as a subclass of PFV for sequential circuits with constant cutwidth, which are verifiable in linear time and space using ASP. We achieve this by proposing a new data structure called Weighted And-Inverter Graph (W-AIG). Unlike existing formal verification methods, we prove that our approach can verify any sequential circuit with a constant cutwidth in linear time and space. Finally, we implement our approach and experimentally show that a variety of sequential circuits, such as pipelined adders, serial adders, and shift registers, can be verified in linear time and space, while ring counters can be verified in polynomial time and space, confirming our theoretical findings.

Optimal component selection of integrated renewable energy system for power generation in stand-alone applications

In this chapter we consider first some of the requirements which different types of multimedia application can impose on speech coders. Then a brief overview of the existing speech coding standards will be given. In Chapter 4, we considered linear prediction techniques which are, in fact, used by almost all modern speech codecs. However, in addition to the high predictability, speech signals have specific features which are used by speech coders and allow us to achieve very high compression ratios. These properties are characterized by such parameters as pitch period, linear spectral parameters , etc. We will explain the meanings of these parameters and describe standard algorithms for finding them. The most important attributes of speech coding are: bit-rate, delay, complexity, and quality. The bit-rate is determined as the number of bits required in order to transmit or store one second of the speech signal. It is measured in kb/s. The range of bit-rates that have been standardized is from 2.4 kb/s for secure telephony up to 64 kb/s for network applications. Table 7.1 shows a list of standardized speech coders. It includes their bit-rates, delays measured in frame size and lookahead requirements, and their complexity in Million Instructions Per Second (MIPS). Several coders standardized by the International Telecommunication Union (ITU) are presented.

We introduce a novel method for learning voice leading using neural networks. Unlike earlier approaches for learning chord sequences where chords are predicted from a local context, this method uses a multi-layer neural network for learning chord assessment from music examples. The network employs a special constraint-based topology for transforming the relative comparison of chord pairs into an absolute assessment function. Using this chord assessment function, globally optimized chord sequences can be found in linear time using the dynamic programming technique. The ChordNet implementation of the approach learns stylistic aspects of voice leading directly from a set of training examples. In combination with the HARMONET system, it presents a powerful framework for solving practical harmonization tasks.

A simple algorithm for the constrained sequence problems