Single-factor lifting and factorization of polynomials over local fields

Let f(x)$f\left(x\right)$ be a separable polynomial over a local field. The Montes algorithm computes certain approximations to the different irreducible factors of f(x)$f\left(x\right)$, with strong arithmetic properties. In this paper, we develop an algorithm to improve any one of these approximations, till a prescribed precision is attained. The most natural application of this “single-factor lifting” routine is to combine it with the Montes algorithm to provide a fast polynomial factorization algorithm. Moreover, the single-factor lifting algorithm may be applied as well to accelerate the computational resolution of several global arithmetic problems in which the improvement of an approximation to a single local irreducible factor of a polynomial is required.     

PolyBoRi: A framework for Gröbner-basis computations with Boolean polynomials

This work presents a new framework for Gröbner-basis computations with Boolean polynomials. Boolean polynomials can be modelled in a rather simple way, with both coefficients and degree per variable lying in {0,1}$\{0,1\}$. The ring of Boolean polynomials is, however, not a polynomial ring, but rather the quotient ring of the polynomial ring over the field with two elements modulo the field equations x²=x$x^2=x$ for each variable x$x$. Therefore, the usual polynomial data structures seem not to be appropriate for fast Gröbner-basis computations. We introduce a specialised data structure for Boolean polynomials based on zero-suppressed binary decision diagrams (ZDDs), which are capable of handling these polynomials more efficiently with respect to memory consumption and also computational speed. Furthermore, we concentrate on high-level algorithmic aspects, taking into account the new data structures as well as structural properties of Boolean polynomials. For example, a new useless-pair criterion for Gröbner-basis computations in Boolean rings is introduced. One of the motivations for our work is the growing importance of formal hardware and software verification based on Boolean expressions, which suffer–besides from the complexity of the problems –from the lack of an adequate treatment of arithmetic components. We are convinced that algebraic methods are more suited and we believe that our preliminary implementation shows that Gröbner-bases on specific data structures can be capable of handling problems of industrial size.     

Quadrature using 64-bit IEEE arithmetic for integrands over [0,1] with a singularity at 1

We present a detailed study of some problems encountered when quadrature over [0,1]$[0,1]$ is attempted with integrands that have a singularity at 1. Methods designed to increase the accuracy of such quadratures, for example, the application of periodising transformations, are examined in the context of the representational limitations of 64-bit IEEE arithmetic near 1 in [0,1]$[0,1]$. A heuristic is proposed for the forecasting of a lower bound on the irremovable error due to these limitations. We conclude by affirming the commonly accepted procedure that where possible, integrals should be symbolically transformed so that any remaining singularity occurs at 0.     

Approximately optimal trees for group key management with batch updates

We investigate the group key management problem for broadcasting applications. Previous work showed that, in handling key updates, batch rekeying can be more cost effective than individual rekeying. One model for batch rekeying is to assume that every user has probability p$p$ of being replaced by a new user during a batch period with the total number of users unchanged. Under this model, it was recently shown that an optimal key tree can be constructed in linear time when p$p$ is a constant and in O(n⁴)$O\left(n^4\right)$ time when p→0$p\to 0$. In this paper, we investigate more efficient algorithms for the case p→0$p\to 0$, i.e., when membership changes are sparse. We design an O(n)$O\left(n\right)$ heuristic algorithm for the sparse case and show that it produces a nearly 2-approximation to the optimal key tree. Simulation results show that its performance is even better in practice. We also design a refined heuristic algorithm and show that it achieves an approximation ratio of 1+?$1+?$ for any fixed ?>0$?>0$ and n$n$, as p→0$p\to 0$. Finally, we give another approximation algorithm for any p∈(0,0.693)$p\in (0,0.693)$ which is shown to be quite good by our simulations.     

On asymptotic extrapolation

Consider a power series f∈R[[z]]$f\in \mathbb{R}\left[\left[z\right]\right]$, which is obtained by a precise mathematical construction. For instance, f$f$ might be the solution to some differential or functional initial value problem or the diagonal of the solution to a partial differential equation. In cases when no suitable method is available beforehand for determining the asymptotics of the coefficients _fn$f_n$, but when many such coefficients can be computed with high accuracy, it would be useful if a plausible asymptotic expansion for _fn$f_n$ could be guessed automatically.     

MinT—Architecture and applications of the (t, m, s)-net and OOA database

Many different constructions for (t,m,s)$(t\text{,}m\text{,}s)$-nets and (t,s)$(t\text{,}s)$-sequences are known today. Propagation rules as well as connections to other mathematical objects make it difficult to determine the best net available in a given setting.     

Modular Las Vegas algorithms for polynomial absolute factorization

Let f(X,Y)∈Z[X,Y]$f(X,Y)\in \mathbb{Z}[X,Y]$ be an irreducible polynomial over Q$\mathbb{Q}$. We give a Las Vegas absolute irreducibility test based on a property of the Newton polytope of f$f$, or more precisely, of f$f$ modulo some prime integer p$p$. The same idea of choosing a p$p$ satisfying some prescribed properties together with LLL$LLL$ is used to provide a new strategy for absolute factorization of f(X,Y)$f(X,Y)$. We present our approach in the bivariate case but the techniques extend to the multivariate case. Maple computations show that it is efficient and promising as we are able to construct the algebraic extension containing one absolute factor of a polynomial of degree up to 400.     

A two-stage hardware scheduler combining greedy and optimal scheduling

Greedy scheduling heuristics provide a low complexity and scalable albeit particularly sub-optimal strategy for hardware-based crossbar schedulers. In contrast, the maximum matching algorithm for Bipartite graphs can be used to provide optimal scheduling for crossbar-based interconnection networks with a significant complexity and scalability cost. In this paper, we show how maximum matching can be reformulated in terms of Boolean operations rather than the more traditional formulations. By leveraging the inherent parallelism available in custom hardware design, we reformulate maximum matching in terms of Boolean operations rather than matrix computations and introduce three maximum matching implementations in hardware. Specifically, we examine a Pure Logic Scheduler with three dimensions of parallelism, a Matrix Scheduler with two dimensions of parallelism and a Vector Scheduler with one dimension of parallelism. These designs reduce the algorithmic complexity for an N×N$N\times N$ network from O(N³)$O\left(N^3\right)$ to O(1)$O\left(1\right)$, O(K)$O\left(K\right)$, and O(KN)$O\left(KN\right)$, respectively, where K$K$ is the number of optimization steps. While an optimal scheduling algorithm requires K=2N−1$K=2N-1$ steps, by starting with our hardware-based greedy strategy to generate an initial schedule, our simulation results show that the maximum matching scheduler can achieve 99% of the optimal schedule when K=9$K=9$. We examine hardware and time complexity of these architectures for crossbar sizes of up to N=1024$N=1024$. Using FPGA synthesis results, we show that a greedy schedule for crossbars, ranging from 8×8 to 256×256, can be optimized in less than 20 ns per optimization step. For crossbars reaching 1024×1024 the scheduling can be completed in approximately 10 μs with current technology and could reach under 90 ns with future technologies.     

An efficient construction of one-to-many node-disjoint paths in folded hypercubes

A folded hypercube is basically a hypercube with additional links augmented, where the additional links connect all pairs of nodes with longest distance in the hypercube. In an n$n$-dimensional folded hypercube, it has been shown that n+1$n+1$ node-disjoint paths from one source node to other n+1$n+1$ (mutually) distinct destination nodes, respectively, can be constructed in O(n⁴)$O\left(n^4\right)$ time so that their maximal length is not greater than ⌈n/2⌉+1$\lceil n/2\rceil +1$, where n+1$n+1$ is the connectivity and ⌈n/2⌉$\lceil n/2\rceil$ is the diameter. Besides, their maximal length is minimized in the worst case. In this paper, we further show that by minimizing the computations of minimal routing functions, these node-disjoint paths can be constructed in O(n³)$O\left(n^3\right)$ time, which is more efficient, and is hard to be reduced because it must take O(n³)$O\left(n^3\right)$ time to compute a minimal routing function by solving a corresponding maximum weighted bipartite matching problem with the best known algorithm.     

The complexity of the zero-sum 3-flows

A zero-sum k-flow for a graph G   is a vector in the null-space of the 0,1$0,1$-incidence matrix of G   such that its entries belong to {±1,?,±(k−1)}$\{\pm 1,?,\pm (k-1)\}$. Akbari et al. (2009) [5] conjectured that if G is a graph with a zero-sum flow, then G   admits a zero-sum 6-flow. (2,3)$(2,3)$-semiregular graphs are an important family in studying zero-sum flows. Akbari et al. (2009) [5] proved that if Zero-Sum Conjecture is true for any (2,3)$(2,3)$-semiregular graph, then it is true for any graph. In this paper, we show that there is a polynomial time algorithm to determine whether a given (2,3)$(2,3)$-graph G   has a zero-sum 3-flow. In fact, we show that, there is a polynomial time algorithm to determine whether a given (2,4)$(2,4)$-graph G with n   vertices has a zero-sum 3-flow, where the number of vertices of degree four is O(log?n)$O(\log ?n)$. Furthermore, we show that it is NP-complete to determine whether a given (3,4)$(3,4)$-semiregular graph has a zero-sum 3-flow.     

Online interval scheduling on a single machine with finite lookahead

We study an online weighted interval scheduling problem on a single machine, where all intervals have unit length and the objective is to maximize the total weight of all completed intervals. We investigate how the function of finite lookahead improves the competitivities of deterministic online heuristics, under both preemptive and non-preemptive models. The lookahead model studied in this paper is that an online heuristic is said to have a lookahead ability of LD if at any time point it is able to foresee all the intervals to be released within the next LD   units of time. We investigate both competitive online heuristics and lower bounds on the competitive ratio, with lookahead 0≤LD≤1$0\le \mathit{LD}\le 1$ under the preemptive model, and lookahead 0≤LD≤2$0\le \mathit{LD}\le 2$ under the non-preemptive model. A method to transform a preemptive lookahead online algorithm to a non-preemptive online algorithm with enhanced lookahead ability is also given. Computational tests are performed to compare the practical competitivities of the online heuristics with different lookahead abilities.     

Optimal trade-off for Merkle tree traversal

In this paper we describe optimal trade-offs between time and space complexity of Merkle tree traversals with their associated authentication paths, improving on the previous results of M. Jakobsson, T. Leighton, S. Micali, and M. Szydlo [Fractal Merkle tree representation and traversal, in: RSA Cryptographers Track, RSA Security Conference, 2003] and M. Szydlo [Merkle tree traversal in log space and time, in: Proc. Eurocrypt, in: LNCS, vol. 3027, 2004, pp. 541–554; Merkle tree traversal in log space and time, Preprint version 2003, available at http://www.szydlo.com]. In particular, we show that our algorithm requires 2logn/log⁽³⁾n$2logn/{log}^{\left(3\right)}n$ hash function computations and storage for less than (logn/log⁽³⁾n+1)loglogn+2logn$(logn/{log}^{\left(3\right)}n+1)loglogn+2logn$ hash values, where n$n$ is the number of leaves in the Merkle tree. We also prove that these trade-offs are optimal, i.e. there is no algorithm that requires less than O(logn/logt)$O(logn/logt)$ time and less than O(tlogn/logt)$O(tlogn/logt)$ space for any choice of parameter t≥2$t\ge 2$.     

A domain decomposition strategy for alignment of multiple biological sequences on multiprocessor platforms

Multiple Sequences Alignment (MSA) of biological sequences is a fundamental problem in computational biology due to its critical significance in wide ranging applications including haplotype reconstruction, sequence homology, phylogenetic analysis, and prediction of evolutionary origins. The MSA problem is considered NP-hard and known heuristics for the problem do not scale well with increasing numbers of sequences. On the other hand, with the advent of a new breed of fast sequencing techniques it is now possible to generate thousands of sequences very quickly. For rapid sequence analysis, it is therefore desirable to develop fast MSA algorithms that scale well with an increase in the dataset size. In this paper, we present a novel domain decomposition based technique to solve the MSA problem on multiprocessing platforms. The domain decomposition based technique, in addition to yielding better quality, gives enormous advantages in terms of execution time and memory requirements. The proposed strategy allows one to decrease the time complexity of any known heuristic of O(N)^x$O{\left(N\right)}^x$ complexity by a factor of O(1/p)^x$O{(1/p)}^x$, where N$N$ is the number of sequences, x$x$ depends on the underlying heuristic approach, and p$p$ is the number of processing nodes. In particular, we propose a highly scalable algorithm, Sample-Align-D, for aligning biological sequences using Muscle system as the underlying heuristic. The proposed algorithm has been implemented on a cluster of workstations using the MPI library. Experimental results for different problem sizes are analyzed in terms of quality of alignment, execution time and speed-up.     

Some properties of the induced continuous ordered weighted geometric operators in group decision making

In Computers and Industrial Engineering 56 (2009) 1545–1552, an induced continuous ordered weighted geometric (ICOWG) operator is presented to deal with group decision making (GDM) problems with interval multiplicative preference relations. But, we still do not know whether the ICOWG operator can improve the consensus among a group of decision makers. The aim of this paper is to study some desired properties of the ICOWG operator in GDM problems. Firstly, the concept of Compatibility Degree and Compatibility Index (CI) is defined. We then present the Compatibility Index induced COWG (CI-ICOWG) operator to aggregate interval multiplicative preference relations, which induces the order of argument values based on the Compatibility Index of decision makers (DMs). The main novelty of the CI-ICOWG operator is that it aggregates individual preference relation in such a way that more importance is placed on the most compatibility one. Thus, the CI-ICOWG operator can guarantee that the Compatibility Degree is at least as good as the arithmetic mean of all the individual Compatibility Degrees. Additionally, if the leading decision maker’s interval multiplicative preference relation P   and each of interval multiplicative preference relations R⁽¹⁾,R⁽²⁾,…,R^(m)$R^{(1)}\text{,}{R}^{(2)}\text{,}\dots \text{,}{R}^{(m)}$ are of acceptable compatibility, then P   and the collective judgement matrix (CJM) of R⁽¹⁾,R⁽²⁾,…,R^(m)$R^{(1)}\text{,}{R}^{(2)}\text{,}\dots \text{,}{R}^{(m)}$ are of acceptable compatibility. Finally, an illustrative numerical example is used to verify the developed approaches.     

Expanders and time-restricted branching programs

The replication number   of a branching program is the minimum number R$R$ such that along every accepting computation at most R$R$ variables are tested more than once; the sets of variables re-tested along different computations may be different. For every branching program, this number lies between 0$0$ (read-once programs) and the total number n$n$ of variables (general branching programs). The best results so far were exponential lower bounds on the size of branching programs with R=o(n/logn)$R=o(n/logn)$. We improve this to R≤?n$R\le ?n$ for a constant ?>0$?>0$. This also gives an alternative and simpler proof of an exponential lower bound for (1+?)n$(1+?)n$ time branching programs for a constant ?>0$?>0$. We prove these lower bounds for quadratic functions of Ramanujan graphs.