Reductions Do Not Preserve Fast Convergence Rates in Average Time

We study the class AvgBPP that consists of distributional problems which can be solved in average polynomial time (in terms of Levin's average-case complexity) by randomized algorithms with bounded error. We prove that there exists a distributional problem that is complete for AvgBPP under polynomial-time samplable distributions. Since we use deterministic reductions, the existence of a deterministic algorithm with average polynomial running time for our problem would imply AvgP = AvgBPP. Note that, while it is easy to construct a promise problem that is complete for $\bf promise\mbox{-}BPP$ [Mil01], it is unknown whether BPP contains complete languages . We also prove a time hierarchy theorem for AvgBPP (there are no known time hierarchy theorems for BPP). We compare average-case classes with their classical (worst-case) counterparts and show that the inclusions are proper.

Polynomial-average-time satisfiability problems

Using a fast convergence rate to measure computation time on average has recently been investigated [CS95a], which modifies the notion of T-time on average [BCGL92]. This modification admits an average-case time hierarchy which is independent of distributions and is as tight as the Hartmanis-Sterns hierarchy for the worst-case deterministic time [HS65]. Various notions of reductions, defined by Levin [Lev86] and others, have played a central role in studying average-case complexity. However, unless the class of admissible distributions is restricted, these notions of reductions cannot be applied to the modified definition. In particular, we show that under the modified definition, there exists a problem which is not computable in average polynomial time, but is efficiently reducible to one that is. We hope that this observation can further stimulate research on finding suitable reductions in this new line of investigation.

Average polynomial time complexity of some NP-complete problems

Structures of polynomial-time computable distributions and polynomial-time many-one reductions on randomized decision problems are investigated. The scope is widened from the most studied class DNP (distributional-NP) to the class ANP (average-NP), which consists of randomized decision problems accepted by nondeterministic Turing machines in average polynomial time. Results indicate that the structures of average-case complexity classes are very different from their counterparts in worst-case complexity due to the complex structures of probability distributions and distribution functions. >

Predicting students’ course grades is an essential element in teaching. This paper used decision tree generation rules to study the prediction of students’ ideological and political course grades. Firstly, ID3 and C4.5 algorithms were briefly introduced; then, an improved C4.5 algorithm with higher computational efficiency was put forward. The formula of the C4.5 algorithm was optimized using theories such as the Taylor series. Finally, experiments were performed on the UCI dataset and students’ ideological and political course datasets. The results suggested that the average classification accuracy and computation time of the improved C4.5 algorithm was 79.37% and 74.1 ms, respectively, on the UCI dataset, which was better than the traditional C4.5 algorithm. Then, the experiment predicting students’ course grades demonstrated that the average quiz grade and the number of video views had the greatest impact on the final grades. The prediction accuracy of the improved C4.5 algorithm reached 93.46%, and the average computation time was 54.8 ms, which was 19.17% less than the C4.5 algorithm. The experimental results verify the effectiveness of the generation rule of the improved C4.5 algorithm in predicting students’ ideological and political course grades. This algorithm can be applied in the actual grade prediction.

Most of works on the time complexity analysis of evolutionary algorithms have always focused on some artificial binary problems. The time complexity of the algorithms for combinatorial optimisation has not been well understood. This paper considers the time complexity of an evolutionary algorithm for a classical combinatorial optimisation problem, to find the maximum cardinality matching in a graph. It is shown that the evolutionary algorithm can produce a matching with nearly maximum cardinality in average polynomial time.

In 1998, at the request of the International Mathematical Union, Steve Smale published a list of mathematical problems for the twenty-first century. The 17th problem in the list reads as follows: Can a zero of n complex polynomial equations in n unknowns be found approximately, on the average, in polynomial time with a uniform algorithm? Using the framework developed in the previous chapters, it is easy to give precise meaning to the terms “approximately”, “average”, and “uniform algorithm”. However, as of today, there is no conclusive answer to this problem. But a number of partial results towards such an answer have been obtained in recent years. We devote this and the next chapter to the exposition of these results. The core of this is an algorithm, proposed by Carlos Beltran and Luis Miguel Pardo, that finds an approximate zero in average polynomial time but makes random choices (flips coins, so to speak) during the computation. This adaptive homotopy algorithm with random start system leads to a probabilistic solution of Smale’s 17th problem.

Let g 1, and let Q2 Z[x] be a monic, squarefree polynomial of degree 2g + 1. For an odd prime p not dividing the discriminant of Q, let Zp(T ) denote the zeta function of the hyperelliptic curve of genus g over the nite eld Fp obtained by reducing the coecients of the equation y 2 = Q(x) modulo p. We present an explicit deterministic algorithm that given as input Q and a positive integer N, computes Zp(T ) simultaneously for all such primes p < N, whose average complexity per prime is polynomial in g, logN, and the number of bits required to represent Q.

At this time, research topic about the nano scale particle dynamics simulation is an emerging research today. Some particle simulation using Euler integration method, but Euler method is the simplest integration method and used only for the smooth particle moving. For extreme abrupt motion of particle, it is necessary to study other integration methods. This paper discusses the computing comparison of Euler, Heun, fourth order Runge-Kutta and third order Adams-Bashforth-Moulton integration used in particle dynamics simulation. The program written in C++ programming languages using Microsoft Visual Studio 2010 compiler and run on Intel i7 processor. The results of computational simulations show that the Euler integration method is the fastest integration with average computation time at 0.055592 second. Whereas the slowest integration is Adams – Bashforth – Moulton with average computation time at 0.055869 second. Simulations also shows that Euler integration method is suitable for smooth motion of particle, whereas Adam-Bashforth-Moulton integration method is suitable for extreme abrupt motion of particle.

In this paper, a new approach for the realization of 1D discrete cosine transform (1D-DCT) is presented. This approach is based on a new formulation of an odd prime-length DCT which uses two half-length cyclic convolutions with the same form which can be computed in parallel. Using this approach, a new efficient systolic array with outstanding performance in structural regularity, hardware cost of the PE's, average computation time, and I/O cost has been obtained, which is well suited for VLSI realization. The average computation time has been reduced to one half and the throughput has been doubled, as compared with a previous design. It possesses also a much lower control complexity, a simpler interconnection structure, and a simpler hardware structure of the PE's, having thus a shorter cycle time. Moreover, it owns all other outstanding features of the systolic array previously proposed.

In this paper, what we believe to be, a new combined algorithm of artificial bee colony and slime mould algorithm (CABCSMA) and a differential evolution (DE) algorithm using target-to-best variation strategy are proposed to process the data based on Planck's radiation law and the mathematical model of reference temperature. The material model with 6 different emissivity trends is simulated. Simulation results show that the average relative error of CABCSMA algorithm is less than 0.68%, and the average calculation time is 0.44s. The average relative error of DE algorithm is less than 0.43%, and the average calculation time is only 0.06s. The two algorithms were applied to the temperature test of silicon carbide sample, tungsten material and rocket engine nozzle. The experimental results show that the relative error of silicon carbide experimental temperature is less than 0.41% and 0.28%, and the relative error of tungsten material experimental temperature is less than 0.31% and 0.3%. The relative errors of rocket engine nozzle temperature experiments are within 0.68% and 0.52%, respectively. The results show that these two algorithms are expected to be applied in practical measurement scenarios.

The graph coloring problem is to color a given graph with the minimum number of colors. This problem is known to be NP-hard even if we are only aiming at approximate solutions. On the other hand, the best known approximation algorithms require $n^\delta (\delta>0)$ colors even for bounded chromatic k-colorable for fixed k n-vertex graphs. The situation changes dramatically if we look at the average performance of an algorithm rather than its worst case performance. A k-colorable graph drawn from certain classes of distributions can be k-colored almost surely in polynomial time. It is also possible to k-color such random graphs in polynomial average time. In this paper, we present polynomial time algorithms for k-coloring graphs drawn from the semirandom model. In this model, the graph is supplied by an adversary each of whose decisions regarding inclusion of edges is reversed with some probability p. In terms of randomness, this model lies between the worst case model and the usual random model where each edge is chosen with equal probability. We present polynomial time algorithms of two different types. The first type of algorithms w always run in polynomial time and succeed almost surely. Blum and Spencer [J. Algorithms, 19, 204-234 1995] have also obtained independently such algorithms, but our results are based on different proof techniques which are interesting in their own right. The second type of algorithms always succeed and have polynomial running time on the average. Such algorithms are more useful and more difficult to obtain than the first type of algorithms. Our algorithms work for semirandom graphs drawn from a wide range of distributions and work $p \ge n^{-{\alpha (k)}+\epsilon}}$ Where $\alpha(k) = \frac{(2k)}{((k-1)(k+2))}$ and \epsilon is a positive constant.

Under a standard hardness assumption we exactly characterize the worst-case running time of languages that are in average polynomial-time over all polynomial-time samplable distributions. More precisely we show that if exponential time is not infinitely often in subexponential space, then the following are equivalent for any algorithm $A$: \begin{itemize} \item For all $\p$-samplable distributions $\mu$, $A$ runs in time polynomial on $\mu$-average. \item For all polynomial $p$, the running time for A is bounded by $2^{O(K^p(x)-K(x)+\log(|x|))}$ for \emph{all} inputs $x$. \end{itemize} where $K(x)$ is the Kolmogorov complexity (size of smallest program generating $x$) and $K^p(x)$ is the size of the smallest program generating $x$ within time $p(|x|)$. To prove this result we show that, under the hardness assumption, the polynomial-time Kolmogorov distribution, $m^p(x)=2^{-K^p(x)}$, is universal among the P-samplable distributions.

Average case time complexity is widely used to evaluate the efficiency of an algorithm [2]. Given a blackbox function, if a tester wants to know the average case time complexity, he/she has to analyze the source code and make input assumption so as to know the average case of the function. Although that is feasible, it is time consuming and that makes the testing process no longer automatic. In this paper, we propose an approach for estimating the average case time complexity of a given black-box function without analyzing source codes. Experimental results show that our approach can accurately estimate the average case time complexity without reading the source code.