Fast Simulation of Cellular Automata by Self-Composition

The scientific research community has reached a stage of maturity where its strong need for high-performance computing has diffused into also everyday life of engineering and industry algorithms. In efforts to satisfy this need, parallel computers provide an efficient and economical way to solve large-scale and/or time-constrained problems. As a consequence, the end-users of these systems have a vested interest in defining the asymptotic time complexity of parallel algorithms to predict their performance on a particular parallel computer. The asymptotic parallel time complexity of data-dependent algorithms depends on the number of processors, data size, and other parameters. Discovering the main other parameters is a challenging problem and the clue in obtaining a good estimate of performance order. Great examples of these types of applications are sorting algorithms, searching algorithms and solvers of the traveling salesman problem (TSP). This article encompasses all the knowledge discovery aspects to the problem of defining the asymptotic parallel time complexity of data-dependent algorithms. The knowledge discovery methodology begins by designing a considerable number of experiments and measuring their execution times. Then, an interactive and iterative process explores data in search of patterns and/or relationships detecting some parameters that affect performance. Knowing the key parameters which characterise time complexity, it becomes possible to hypothesise to restart the process and to produce a subsequent improved time complexity model. Finally, the methodology predicts the performance order for new data sets on a particular parallel computer by replacing a numerical identification. As a case of study, a global pruning traveling salesman problem implementation (GP-TSP) has been chosen to analyze the influence of indeterminism in performance prediction of data-dependent parallel algorithms, and also to show the usefulness of the defined knowledge discovery methodology. The subsequent hypotheses generated to define the asymptotic parallel time complexity of the TSP were corroborated one by one. The experimental results confirm the expected capability of the proposed methodology; the predictions of performance time order were rather good comparing with real execution time (in the order of 85%).

This article examines the asymptotic time complexity development for several approaches to compute the rectangular determinants. In this analysis are taken into consideration the Cullis/Radic method which has asymptotic time complexity of <tex xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">$O\left(C\binom {n}{m}\cdot m^{3}\right)$</tex> , Laplace method with the asymptotic time complexity calculated as <tex xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">$O(m!\cdot(n-m))$</tex> , Chios-like method that has asymptotic time complexity as <tex xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">$o(m^{2}\cdot n\cdot(n-m))$</tex> and Dodgson's condensation methods which have asymptotic time complexity of <tex xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">$O(2^{2m}\cdot(n-m)^{2})$</tex> . According to the calculations of time complexity growth for different order of matrices, the Chios-like method is the most useful method for computing rectangular matrices' determinant.

Computational science (CS) is often referred to as the third science, complementing both theoretical and laboratory science. In this field, new challenges are continuously arising. It allows doing things that were previously too difficult to do due to the complexity of the mathematics, the large number of calculations involved, or a combination of both. The asymptotic time complexity definition of both deterministic and non-deterministic algorithms to solve all kind of problems is one of the key points in computer science. Knowing the limit of the execution time of an algorithm when the size of the problem goes to infinity is essential. In particular, data-dependent applications is an extremely challenging problem because for a specific issue the input data sets may cause variability in execution times. The development of an entire approach to define the asymptotic time complexity of a hard data-dependent parallel application that solves the traveling salesman problem (TSP) is the focus of this study. This is a process designed to explore data in search of patterns and/or relationships, and then to predict performance order for new data sets by applying historical detected patterns. Two different parallel TSP algorithms are presented. One of these is used to show the usefulness and the profits of the proposed approach, and the other one is used as witness. The experimental results are quite promising.

In 2010, Bouillaguet et al. proposed an efficient solver for polynomial systems over \(\mathbb {F}_{2}\) that trades memory for speed [BCC+10]. As a result, 48 quadratic equations in 48 variables can be solved on a graphics processing unit (GPU) in 21 min. The research question that we would like to answer in this paper is how specifically designed hardware performs on this task. We approach the answer by solving multivariate quadratic systems on reconfigurable hardware, namely Field-Programmable Gate Arrays (FPGAs). We show that, although the algorithm proposed in [BCC+10] has a better asymptotic time complexity than traditional enumeration algorithms, it does not have a better asymptotic complexity in terms of silicon area. Nevertheless, our FPGA implementation consumes 20–25 times less energy than its GPU counterpart. This is a significant improvement, not to mention that the monetary cost per unit of computational power for FPGAs is generally much cheaper than that of GPUs.KeywordsMultivariate quadratic polynomialsSolving systems of equationsExhaustive searchParallelizationField-Programmable Gate Arrays (FPGAs)

The run-time verification logic Eagle is equipped with two forms of binary cut operator, sequential composition (;) and concatenation (·). Essentially, a concatenation formula F 1 ·F 2 holds on a trace if that trace can be cut into two non-overlapping traces such that F 1 holds on the first and F 2 on the second. Sequential composition differs from concatenation in that the two traces must overlap by one state. Both cut operators are non-deterministic in the sense that the cutting point is not uniquely defined. In this paper we establish that sequential composition and concatenation are equally expressive. We then extend Eagle with deterministic variants of sequential composition and concatenation. These variants impose a restriction on either the left or right operand so that the cut point defines either the shortest or longest possible satisfiable cut trace. Whilst it is possible to define such deterministic operators recursively within Eagle , such definitions based on the non-deterministic cut operators impose a complexity penalty. By augmenting Eagle 's evaluation calculus for the deterministic variants, we establish that the asymptotic time and space complexity of on-line monitoring for the variants with deterministic restrictions applied to the left operand is no worse than the asymptotic time and space complexity of the sub-formulae.

In this review paper we embed several constraint propagation algorithms inside a backtracking algorithm in order to solve constraint satisfaction problems and analyse the time complexities. To get a common frame for presenting the diverse algorithms we provide formal definitions for a uniform treatment of constraint satisfaction problems. For some constraint satisfaction algorithms we prove that their asymptotic total worst-case time complexities are equal to that of ordinary backtracking. If the constraint satisfaction problems are binary, the asymptotic total worst-case time complexities of these algorithms are even better and optimal in the sense that there is no algorithm which improves these complexity bounds. Furthermore, we present a new algorithm that establishes global consistency.

Commonly used RNA folding programs compute the minimum free energy structure of a sequence under the pseudoknot exclusion constraint. They are based on Zuker's algorithm which runs in time O(n(3)). Recently, it has been claimed that RNA folding can be achieved in average time O(n(2)) using a sparsification technique. A proof of quadratic time complexity was based on the assumption that computational RNA folding obeys the "polymer-zeta property". Several variants of sparse RNA folding algorithms were later developed. Here, we present our own version, which is readily applicable to existing RNA folding programs, as it is extremely simple and does not require any new data structure. We applied it to the widely used Vienna RNAfold program, to create sibRNAfold, the first public sparsified version of a standard RNA folding program. To gain a better understanding of the time complexity of sparsified RNA folding in general, we carried out a thorough run time analysis with synthetic random sequences, both in the context of energy minimization and base pairing maximization. Contrary to previous claims, the asymptotic time complexity of a sparsified RNA folding algorithm using standard energy parameters remains O(n(3)) under a wide variety of conditions. Consistent with our run-time analysis, we found that RNA folding does not obey the "polymer-zeta property" as claimed previously. Yet, a basic version of a sparsified RNA folding algorithm provides 15- to 50-fold speed gain. Surprisingly, the same sparsification technique has a different effect when applied to base pairing optimization. There, its asymptotic running time complexity appears to be either quadratic or cubic depending on the base composition. The code used in this work is available at: .

We propose a novel secret image sharing scheme with ciphertext‐based share authentication (SISS‐CSA) for sharing grayscale and color secret images in the malicious model. In SISS‐CSA, the dealer and each participant, individually acting as a combiner, can identify each invalid share received from the malicious participant(s) before using it to reconstruct the secret image. This capability, which most comparable schemes lack, prevents reconstructing an incorrect secret image. In SISS‐CSA, the asymptotic time complexities of operations executed by the dealer in the shares generation phase and executed by each combiner in the secret image reconstruction phase are and , respectively. Here, is the number of grayscale values in the secret image, is the number of generated shares, and is the threshold number of shares required for reconstructing the secret image. These asymptotic time complexities and the size of additional information each combiner stores for identifying invalid share(s) are comparatively lesser than those in the state‐of‐the‐art schemes. Furthermore, we obtain a maximum of reduction in the size of additional information each combiner stores for share authentication using the ciphertext‐based share authentication compared to using the standard SHA‐256. To the best of our knowledge, none of the related share authentication approaches achieves this much reduction. We prove the properties of SISS‐CSA using theoretical analysis. We also provide experimental results validating the implications of theoretical analysis corresponding to asymptotic time complexities and the random nature of shares.

The polynomial multiplication problem has attracted considerable attention since the early days of computer algebra, and several algorithms have been designed to achieve the best possible time complexity. More recently, efforts have been made to improve the space complexity, developing modified versions of a few specific algorithms to use no extra space while keeping the same asymptotic running time. In this work, we broaden the scope in two regards. First, we ask whether an arbitrary multiplication algorithm can be performed in-place generically. Second, we consider two important variants which produce only part of the result (and hence have less space to work with), the so-called middle and short products, and ask whether these operations can also be performed in-place. To answer both questions in (mostly) the affirmative, we provide a series of reductions starting with any linear-space multiplication algorithm. For full and short product algorithms these reductions yield in-place versions with the same asymptotic time complexity as the out-of-place version. For the middle product, the reduction incurs an extra logarithmic factor in the time complexity only when the algorithm is quasi-linear.

A one-dimensional cellular automaton τ : A Z → A Z is a transformation of the full shift defined via a finite neighbourhood S ⊂ Z and a local function μ : A S → A . We study the family of cellular automata whose finite neighbourhood S is an interval containing 0, and there exists a pattern p ∈ A S satisfying that μ ( z ) = z ( 0 ) if and only if z ≠ p ; this means that these cellular automata have a unique active transition. Despite its simplicity, this family presents interesting and subtle problems, as the behaviour of the cellular automaton completely depends on the structure of p. We show that every cellular automaton τ with a unique active transition p ∈ A S is either idempotent or strictly almost equicontinuous, and we completely characterize each one of these situations in terms of p. In essence, the idempotence of τ depends on the existence of a certain subpattern of p with a translational symmetry.

Various Data Structures have been introduced till date that aim at either to improve them in terms of time or space complexity or they are particularly designed for some special applications. This work aims at developing a new data structure that takes the idea of plotting each digit to another dimension and thereby reducing the access time for keys stored in it. In order to make it practical to implement, a tree-based approach has been used to store it in the memory. The asymptotic time complexity is O(nu) for extracting the keys in sorted order where u is the size of universe. In practical testing, the procedure took much less time to complete as compared to Merge Sort which is the best Comparison based Sorting Technique in terms of worst-case time complexity. This work discusses the concept, implementation and algorithms associated with the data structure. Then it evaluates it against various test scenarios with other sorting techniques.

Ordinal regression is one of the most important tasks of relation learning, and several techniques based on support vector machines (SVMs) have also been proposed for tackling it, but the scalability aspect of these approaches to handle large datasets still needs much of exploration. In this paper, we will extend the recent proposed algorithm Core Vector Machine (CVM) to the ordinal-class data, and propose a new algorithm named as Ordinal-Class Core Vector Machine (OCVM). Similar with CVM, its asymptotic time complexity is linear with the number of training samples, while the space complexity is independent with the number of training samples. We also give some analysis for OCVM, which mainly includes two parts, the first one shows that OCVM can guarantee that the biases are unique and properly ordered under some situation; the second one illustrates the approximate convergence of the solution from the viewpoints of objective function and KKT conditions. Experiments on several synthetic and real world datasets demonstrate that OCVM scales well with the size of the dataset and can achieve comparable generalization performance with existing SVM implementations.

We present an N-process local-spin mutual exclusion algorithm, based on nonatomic reads and writes, in which each process performs Θ(log N) remote memory references to enter and exit its critical section. This algorithm is derived from Yang and Anderson's atomic tree-based local-spin algorithm in a way that preserves its time complexity. No atomic read/write algorithm with better asymptotic worst-case time complexity (under the remote-mem-ory-refer-ences measure) is currently known. This suggests that atomic memory is not fundamentally required if one is interested in worst-case time complexity. The same cannot be said if one is interested in fast-path algorithms (in which contention-free time complexity is required to be O(1)) or adaptive algorithms (in which time complexity is required to depend only on the number of contending processes). We show that such algorithms fundamentally require memory accesses to be atomic. In particular, we show that for any N-process nonatomic algorithm, there exists a single-process execution in which the lone competing process accesses Ω(log N/log log N) distinct variables to enter its critical section. Thus, fast and adaptive algorithms are impossible even if caching techniques are used to avoid accessing the processors-to-memory interconnection network.

Verifying the correctness of executions of concurrent and distributed programs is difficult because they show nondeterministic behavior due to different process scheduling order. Predicate detection can alleviate this problem by predicting whether the user-specified condition (predicate) could have become true in any global state of the given concurrent or distributed computation. The method is predictive because it generates inferred global states from the observed execution path and then checks if those global states satisfy the predicate. An important part of the predicate detection method is global states enumeration, which generates the consistent global states, including the inferred ones, of the given computation. Cooper and Marzullo gave the first enumeration algorithm based on a breadth first strategy (BFS). Later, many algorithms have been proposed to improve the space and time complexity. Among the existing algorithms, the Tree algorithm due to Jegou et al. has the smallest time complexity and requires O(|P|) space, which is linear to the size of the computation P. In this paper, we present a fast algorithm, QuickLex, to enumerate global states in the lexical order. QuickLex requires much smaller space than O(|P|). From our experiments, the Tree algorithm requires 2-10 times more memory space than QuickLex. Moreover, QuickLex is 4 times faster than Tree even though the asymptotic time complexity of QuickLex is higher than that of Tree. The reason is that the worst case time complexity of QuickLex happens only in computations that are not common in practice. Moreover, Tree is built on linked-lists and QuickLex can be implemented using integer arrays. In comparison with the existing lexical algorithm (Lex), QuickLex is 7 times faster and uses almost the same amount of memory as Lex. Finally, we implement a parallel-and-online predicate detector for concurrent programs using QuickLex, which can detect data races and violation of invariants in the programs.

We propose a multiconstraint QoS routing scheme using the DFS (depth-first search) method to sequentially search for a feasible routing path. Although the standard sequential search approach has several advantages, it has not been explored for multiconstraint QoS routing in the literature due to its asymptotic exponential worst-case time complexity. Our scheme limits the number of crankbacks per node (crankback degree) to control the worst-case time complexity. The scheme uses a metric, called the normalized margin, to reduce the average-case time complexity by first exploring the paths that are most likely to be feasible. We further tune the crankback degree based on correlation coefficients between QoS attributes to reduce the worst-case time complexity. We use simulations to show that our scheme solves multiconstraint QoS routing problems with a small probability of missing a feasible path while keeping the average-case time complexity low.