Search

In this paper, we study the model checking problem of pushdown systems for projection temporal logic (PTL), an interval-based temporal logic that is as expressive as the full regular languages. For this, we provide an algorithm to decide whether a pushdown system, determined by a pushdown automaton, satisfies a desired logic property, by using relevant automata notations and operations. The algorithm terminates in exponential time for normal PTL properties, i.e. properties specified as normal PTL formulas. To show the lower bound of complexity of the model checking problem, we also construct a polynomial-time reduction from the acceptance problem of a linearly bounded alternating Turing machine. As a result, the model checking problem of pushdown systems for normal PTL properties is EXPTIME-complete.

We study the class of binary coded versions of unary languages that can be accepted by alternating machines with loglog n space. We show that there exists a binary PSpace-complete language $\mathcal {L}$ such that the unary coded version of $\mathcal {L}$ is in ASpace(loglog n). Consequently, the standard translation between unary languages accepted with loglog n space and binary languages accepted with log n space works for alternating machines if and only ifP = PSpace. In general, if a binary language is accepted deterministically in 2n⋅nO(1) time and, simultaneously, in nO(1) space—which covers many PSpace-complete problems—then its unary coded version is accepted by an alternating Turing machine using an initially delimited worktape of size loglog n. This unexpected power follows from the fact that, with an auxiliary worktape of size O(loglog n) on a unary input 1n, an alternating machine can simulate a stack with log n bits, representing the contents of the stack by its input head position. The standard push/pop operations on the stack are implemented by moving the head along the input.

We consider ordered multi-pushdown automata, a multi-stack extension of pushdown automata that comes with a constraint on stack operations: a pop can only be performed on the first non-empty stack (which implies that we assume a linear ordering on the collection of stacks). We show that the emptiness problem for multi-pushdown automata is 2ETIME-complete. Containment in 2ETIME is shown by translating an automaton into a grammar for which we can check if the generated language is empty. The lower bound is established by simulating the behavior of an alternating Turing machine working in exponential space. We also compare ordered multi-pushdown automata with the model of bounded-phase (visibly) multi-stack pushdown automata, which do not impose an ordering on stacks, but restrict the number of alternations of pop operations on different stacks.

Classes of time and space complexity of Turing machines are defined, and relationships between them are discussed. New relationships between the defined complexity classes are described.

We introduce quantum alternation as a generalization of quantum nondeterminism. We define q-alternating Turing machine (qATM) by augmenting alternating Turing machine with constant-size quantum memory. We show that one-way constant-space qATMs (1AQFAs) are Turing equivalent. Then, we introduce strong version of qATM by requiring to halt in every computation path and we show that strong qATMs can simulate deterministic spacewith exponentially less space. This leads to shifting the deterministic space hierarchy exactly by one level. We also focus on realtime versions of 1AQFAs (rtAQFAs) and obtain many results: rtAQFAs can recognize a PSPACE-complete problem; they cannot be simulated by sublinear deterministic Turing machines; for any level of polynomial hierarchy, say k, there exists a complete language that can be recognized by rtAFAs with only (k +1) alternations; and polynomial hierarchy lies in its log-space q-alternation counterpart.

Quantum logic was introduced in 1936 by Garrett Birkhoff and John von Neumann as a framework for capturing the logical peculiarities of quantum observables. It generalizes, and on 1-dimensional Hilbert space coincides with, Boolean propositional logic. We introduce the weak and strong satisfiability problem for quantum logic terms. It turns out that in dimension two both are also NP-complete. For higher-dimensional spaces R^d and C^d with d>2 fixed, on the other hand, we show both problems to be complete for the nondeterministic Blum-Shub-Smale model of real computation. This provides a unified view on both Turing and real BSS complexity theory; and extends the still relatively scarce family of NP_R-complete problems with one perhaps closest in spirit to the classical Cook-Levin Theorem. Our investigations on the dimensions a term is weakly/strongly satisfiable in lead to satisfiability problems in indefinite finite and finally in infinite dimension. Here, strong satisfiability turns out as polynomial-time equivalent to the feasibility of noncommutative integer polynomial equations, full version to extended abstract [HeZi11]

Let $\mathrm{SO}^{\mathit{plog}}$ denote the restriction of second-order logic, where second-order quantification ranges over relations of size at most poly-logarithmic in the size of the structure. In this article we investigate the problem, which Turing machine complexity class is captured by Boolean queries over ordered relational structures that can be expressed in this logic. For this we define a hierarchy of fragments $\Sigma^{\mathit{plog}}_m$ (and $\Pi^{\mathit{plog}}_m$) defined by formulae with alternating blocks of existential and universal second-order quantifiers in quantifier-prenex normal form. We first show that the existential fragment $\Sigma^{\mathit{plog}}_1$ captures NPolyLogTime, i.e. the class of Boolean queries that can be accepted by a non-deterministic Turing machine with random access to the input in time $O((\log n)^k)$ for some $k \ge 0$. Using alternating Turing machines with random access input allows us to characterise also the fragments $\Sigma^{\mathit{plog}}_m$ (and $\Pi^{\mathit{plog}}_m$) as those Boolean queries with at most $m$ alternating blocks of second-order quantifiers that are accepted by an alternating Turing machine. Consequently, $\mathrm{SO}^{\mathit{plog}}$ captures the whole poly-logarithmic time hierarchy. We demonstrate the relevance of this logic and complexity class by several problems in database theory.

We discuss the formalization, in the Matita Theorem Prover, of basic results on multi-tapes Turing machines, up to the existence of a (certified) Universal Machine, and propose it as a natural benchmark for comparing different interactive provers and assessing the state of the art in the mechanization of formal reasoning. The work is meant to be a preliminary step towards the creation of a formal repository in Complexity Theory, and is a small piece in our long-term Reverse Complexity program, aiming to a comfortable, machine independent axiomatization of the field.

We use notions originating in Computational Complexity to provide insight into the analogies between computational complexity and Higher Recursion Theory. We consider alternating Turing machines, but with a modified, global, definition of acceptance. We show that a language is accepted by such a machine iff it is Pi-1-1. Moreover, total alternating machines, which either accept or reject each input, accept precisely the hyper-arithmetical (Delta-1-1) languages. Also, bounding the permissible number of alternations we obtain a characterization of the levels of the arithmetical hierarchy..The novelty of these characterizations lies primarily in the use of finite computing devices, with finitary, discrete, computation steps. We thereby elucidate the correspondence between the polynomial-time and the arithmetical hierarchies, as well as that between the computably-enumerable, the inductive (Pi-1-1), and the PSpace languages.

Recent cyberattacks have demonstrated that current approaches to the malware problem (e.g., detection) are inadequate. This is not surprising as virus detection is Turing undecidable. 1 Further, some recent malware implementations use NP problems to encrypt and hide the malware. 2 Two goals guide an alternative approach: (a) Program execution should hide computational steps in order to hinder “reverse engineering” efforts by malware hackers; (b) New computational models should be explored that make it more difficult to hijack the purpose of program execution. The methods explained here pertain to (a) implemented with a new computational model, called the active element machine (AEM). 3 An AEM is composed of computational primitives called active elements that simultaneously transmit and receive pulses to and from other active elements. Each pulse has an amplitude and a width, representing how long the pulse amplitude lasts as input to the active element receiving the pulse. If active element Ei simultaneously receives pulses with amplitudes summing to a value greater than Ei’s threshold and Ei’s refractory period has expired, then Ei fires. When Ei fires, it sends pulses to other active elements. If Ei fires at time t, a pulse reaches element Ek at time t+ τik where τik is the transmission time from Ei to Ek. The AEM language uses five commands – Element, Connection, Fire, Program and Meta – to write AEM programs, where time is explicitly specified and multiple commands may simultaneously execute. An Element command creates, at the time specified in the command, an active element with a threshold value, a refractory period and a most recent firing time. A Connection command sets, at the time specified in the command, a pulse amplitude, a pulse width and a transmission time from element Ei to element Ek. The Fire command fires an input element at a particular time. The Program command defines the execution of multiple commands with a single command. Element and Connection commands establish the AEM architecture and firing activity. The Meta command can change the AEM architecture during AEM program execution. This model uses quantum random input to generate random firing patterns that deterministically execute a universal Turing machine (UTM) program η. Random firing interpretations are constructed with dynamic level sets on boolean functions that compute η. The quantum randomness is an essential component for building the random firing patterns that are Turing incomputable. 4 It is assumed that the following are all kept perfectly secret: the state and tape of the UTM, represented by the active elements and connections; the quantum random bits determining how η is computed for each computational step; and the dynamic connections in the AEM. Formally, let f1j , f2j , . . . fmj represent the random firing pattern computing η during the jth computational step and assume an adversary can eavesdrop on f1j , f2j , . . . fmj . Let q denote the current state of the UTM, ak a UTM alphabet symbol and qk a UTM state. Perfect secrecy means that probabilities P (q = qk|f1j = b1 . . . fmj = bm) = P (q = qk) and P (Tk = ak|f1j = b1 . . . fmj = bm) = P (Tk = ak) for each bi ∈ {0, 1} and each Tk which is the contents of the kth tape square. If these secrecy conditions hold, then there doesn’t exist a “reverse engineer” Turing machine that can map the random firing patterns back to an unbounded sequence of UTM instructions. For an unbounded number of computational steps, define function g : N→ {0, 1} where g((j − 1)m+ r) = f(r+1)j and 0 ≤ r < m. Then g is incomputable. Proposed methods of hypercomputation currently have no physical realization. 5 The methods described here can be physically realized using an off-the-shelf quantum random generator device with a USB plug connected to a laptop computer executing a finite AEM program.

International audience; Deterministic one-way Turing machines with sublinear space bounds are systematically studied. We distinguish among the notions of strong, weak, and restricted space bounds. The latter is motivated by the study of P automata. The space available on the work tape depends on the number of input symbols read so far, instead of the entire input. The class of functions space constructible by such machines is investigated, and it is shown that every function f that is space constructible by a deterministic two-way Turing machine, is space constructible by a strongly f space-bounded deterministic one-way Turing machine as well. We prove that the restricted mode coincides with the strong mode for space constructible functions. The known infinite, dense, and strict hierarchy of strong space complexity classes is derived also for the weak mode by Kolmogorov complexity arguments. Finally, closure properties under AFL operations, Boolean operations and reversal are shown.

The paper focuses on the relation between biological and computational information processing. Several simple biological operations, as the exchange of molecules via cellular membrane or the cellular growth and separation, are abstracted into a mathematical model called membrane system (P system). This paper studies tissue P systems where a fixed interaction graph defines the communication between various types of cells. Polynomially uniform families of tissue P systems with the operation of cell separation were recently studied. Their computational power in polynomial time was shown to range between P and NP ∪ co - NP , characterizing borderlines between tractability and intractability by the length of rules controlling the interchange of objects. Here, we show that the computational power of these uniform families is limited by the class PSPACE , which is the class characterizing the power of classical parallel computing models, such as PRAM or the alternating Turing machine.

The main topic of the present work is the relation that a set X is strongly hyperimmune-free relative to Y . Here X is strongly hyperimmune-free relative to Y if and only if for every partial X -recursive function p there is a partial Y -recursive function q such that every a in the domain of p is also in the domain of q and satisfies p ( a ) p ( a ) , that is, p is majorised by q . For X being hyperimmune-free relative to Y , one also says that X is pmaj-reducible to Y ( X ≤ pmaj Y ) . It is shown that between degrees not above the Halting problem the pmaj-reducibility coincides with the Turing reducibility and that therefore only recursive sets have a strongly hyperimmune-free Turing degree while those sets Turing above the Halting problem bound uncountably many sets with respect to the pmaj-relation. So pmaj-reduction is identical with Turing reduction on a class of sets of measure 1. Moreover, every pmaj-degree coincides with the corresponding Turing degree. The pmaj-degree of the Halting problem is definable with the pmaj-relation.

The paper studies algorithmic properties of operations with membrane proteins modeled within the framework of membrane systems (also called P systems). Membrane systems are biologically inspired models of parallel and distributed computing based on the information processing in cells and cellular membranes. We show that the computational potential of P systems with proteins on membranes is equivalent to that of parallel computing models as the alternating Turing machine or the PRAM. These abstract machines characterize by their polynomial time-bounded computations the class PSPACE, and simultaneously they serve as idealized models of real parallel machines. Therefore, this and other related results suggest the existence of a homology between the potential of silicon and biological parallel information processing.

We show that there exists a binary PSpace-complete language \({\mathcal {L}}\) such that its unary coded version \({\mathcal {L}}'\) is in \({\textsc {ASpace}}^{\mathrm {dm}}(\log \log n)\), i.e., \({\mathcal {L}}'\) is accepted by an alternating Turing machine using an initially delimited worktape of size \(\log \log n\). As a consequence, the standard translation between unary languages accepted with \(\log \log n\) space and binary languages accepted with \(\log n\) space works for alternating machines if and only if \({\textsc {P}}= {\textsc {PSpace}}\).

We study the precise computational complexity of deciding satisfiability of first-order quantified formulas over the theory of fixed-size bit-vectors with binary-encoded bit-widths and constants. This problem is known to be in EXPSPACE and to be NEXPTIME-hard. We show that this problem is complete for the complexity class AEXP ( poly ) – the class of problems decidable by an alternating Turing machine using exponential time, but only a polynomial number of alternations between existential and universal states.

We investigate two constants cT and rT, introduced by Chaitin and Raatikainen respectively, defined for each recursively axiomatizable consistent theory T and universal Turing machine used to determine Kolmogorov complexity. Raatikainen argued that cT does not represent the complexity of T and found that for two theories S and T, one can always find a universal Turing machine such that . We prove the following are equivalent: for some universal Turing machine, for some universal Turing machine, and T proves some Π1-sentence which S cannnot prove. © 2011 WILEY-VCH Verlag GmbH & Co. KGaA, Weinheim

We prove a number of results in effective randomness, using methods in which Π10 classes play an essential role. The results proved include the fact that every PA Turing degree is the join of two random Turing degrees, and the existence of a minimal pair of LR degrees below the LR degree of the halting problem.

In this paper, we improve some results regarding the size complexity of accepting hybrid networks of evolutionary processors (AHNEPs). We show that there are universal AHNEPs of size 6, by devising a method for simulating 2-tag systems. This result improves the best upper bound for the size of universal AHNEPs which was 7. We also propose a computationally and descriptionally efficient simulation of nondeterministic Turing machines with AHNEPs. More precisely, we prove that AHNEPs with ten nodes can simulate any nondeterministic Turing machine of time complexity f (n) in time O(f (n)). This result significantly improves the best known upper bound for the number of nodes in a network simulating in linear time an arbitrary Turing machine, namely 24.

In this paper we formally define the notion of persistent Turing machines to model interactive computations. We compare the power of persistent Turing machines with respect to computing functions and relations and accepting sets with their classical counterparts. It turns out that the model of persistent computations leads to new characterizations of known function and language classes as well as to classes that have no classical counterpart.

We show that a set has an η-representation in a linear order if and only if it is the range of a 0′-computable limitwise monotonic function. We also construct a Δ3 Turing degree for which no set in that degree has a strong η-representation, answering a question posed by Downey.

We say that A≤LRB if every B-random set is A-random with respect to Martin–Lof randomness. We study this relation and its interactions with Turing reducibility, π10 classes, hyperimmunity and other recursion theoretic notions.

We consider three complexity classes defined on Accepting Hybrid Networks of Evolutionary Processors (AHNEP) and compare them with the classical complexity classes defined on the standard computing model of Turing machine. By definition, AHNEPs are deterministic. We prove that the classical complexity class NP equals the family of languages decided by AHNEPs in polynomial time. A language is in P if and only if it is decided by an AHNEP in polynomial time and space. We also show that PSPACE equals the family of languages decided by AHNEPs in polynomial length.

Based on oracle Turing machines, we investigate the computational complexity of operators on compact sets. For the projection and convex hull we are able to show exponential upper and lower bounds as well as a connection to the P=NP problem for special settings.

In this paper we consider the computational complexity of uniformizing a domain with a given computable boundary. We give nontrivial upper and lower bounds in two settings: when the approximation of the boundary is given either as a list of pixels, or by a Turing machine.

There is a dependency between computability of algorithmic complexity and decidability of different algorithmic problems. It is known that computability of the algorithmic complexity C(x) is equivalent to decidability of the halting problem for Turing machines. Here we extend this result to the realm of superrecursive algorithms, considering algorithmic complexity for inductive Turing machines. We study two types of algorithmic complexity: recursive (classical) and inductive algorithmic complexities. Relations between these types of algorithmic complexity and decidability of algorithmic problems for Turing machines and inductive Turing machines are considered. In particular, it is demonsrated that computability of algorithmic complexity is equivalent not only to decidability of the halting problem, but also to decidability by inductive Turing machines of the first order of many other problems for Turing machines, such as: if a Turing machine computes a recursive (total) function; if a Turing machine gives no result only for n inputs; if a Turing machine gives results only for n inputs.

We study the computational complexity of finding a line that bisects simultaneously two sets in the two-dimensional plane, called the pancake problem, using the oracle Turing machine model of Ko. We also study the basic problem of bisecting a set at a given direction. Our main results are: (1) the complexity of bisecting a nice (thick) polynomial-time approximable set at a given direction can be characterized by the counting class #P; (2) the complexity of bisecting simultaneously two linearly separable nice (thick) polynomial-time approximable sets can be characterized by the counting class #P; and (3) for either of these two problems, without the thickness condition and the linear separability condition (for the two-set case), it is arbitrarily hard to compute the bisector (even if it is unique).

Unambiguity in alternating Turing machines has received considerable attention in the context of analyzing globally unique games by Aida et al. [ACRW] and in the design of efficient protocols involving globally unique games by Crasmaru et al. [CGRS]. This paper explores the power of unambiguity in alternating Turing machines in the following settings: 1. We show that unambiguity-based hierarchies-AUPH, UPH, and UPH-are infinite in some relativized world. For each $k \geq 2$, we construct another relativized world where the unambiguity-based hierarchies collapse so that they have exactly k distinct levels and their k-th levels coincide with PSPACE. These results shed light on the relativized power of the unambiguity-based hierarchies, and parallel the results known for the case of the polynomial hierarchy. 2. For every $k \ge 1$, we define the bounded-level unambiguous alternating solution class UAS(k) as the class of all sets L for which there exists a polynomial-time alternating Turing machine N, which need not be unambiguous on every input, with at most k alternations such that $x\in L$ if and only if x is accepted unambiguously by N. We construct a relativized world where, for all $k \geq 1, {\rm UP}_{\leq k} \subset {\rm UP}_{\leq k+1}$ and ${\rm UAS}(k) \subset {\rm UAS}(k+1)$. 3. Finally, we show that robustly k-level unambiguous alternating polynomial-time Turing machines, i.e., polynomial-time alternating Turing machines that for every oracle have k alternating levels and are unambiguous, accept languages that are computable in ${\rm P}^{\Sigma^{p}_{k} \oplus {\cal A}}$, for every oracle A. This generalizes a result of Hartmanis and Hemachandra [HH].

The relationship between structure and function is explored via a system of labeled directed graph structures upon which a single elementary read/write rule is applied locally. Boundaries between static (information-carrying) and active (information-processing) objects, imposed by mandate of the rules or physics in earlier models, emerge instead as a result of a structure-function dynamic that is reflexive: objects may operate directly on their own structure. A representation of an arbitrary Turing machine is reproduced in terms of structural constraints by means of a simple mapping from tape squares and machine states to a uniform medium of nodes and links, establishing computation universality. Exploiting flexibility of the formulation, examples of other unconventional “self-computing” structures are demonstrated. A straightforward representation of a kinematic machine system based on the model devised by Laing is also reproduced in detail. Implications of the findings are discussed in terms of their relation to other formal models of computation and construction. It is argued that reflexivity of the structure-function relationship is a critical informational dynamic in biochemical systems, overlooked in previous models but well captured by the proposed formulation.

We characterize the classes of languages over finite alphabets which may be described by P automata, i.e., accepting P systems with communication rules only. Motivated by properties of natural computing systems, and the actual behavior of P automata, we study computational complexity classes with a certain restriction on the use of the available workspace in the course of computations and relate these to the language classes described by P automata. We prove that if the rules of the P system are applied sequentially, then the accepted language class is strictly included in the class of languages accepted by one-way Turing machines with a logarithmically bounded workspace, and if the rules are applied in the maximally parallel manner, then the class of context-sensitive languages is obtained.

This paper investigates the accepting powers of two-way alternating Turing machines (2ATM's) with only existential (universal) states which have inkdots and sublogarithmic space. It is shown that for sublogarithmic space-bounded computations, (i) multi-inkdot 2ATM's with only existential states and the ones with only universal states are incomparable, (ii) k-inkdot 2ATM's are better than k-inkdot 2ATM's with only existential (universal) states, k ≥ 0, and (iii) the class of sets accepted by multi-inkdot 2ATM's with only existential (universal) states is not closed under complementation.

We propose a construction of an accepting hybrid network of evolutionary processors (AHNEP) which behaves as a universal device in the class of all these devices. We first construct a Turing machine which can simulate any AHNEP and then an AHNEP which simulates the Turing machine. We think that this approach can be applied to other bio-inspired computing models which are computationally complete.

Extending results of Schindler, Hamkins and Welch, we establish in the context of infinite time Turing machines that P is properly contained in NP ∩ co-NP. For higher analogues of these classes, we exhibit positive and negative results.

We prove that the existential theory of the Turing degrees, in the language with Turing reduction, 0, and unary relations for the classes in the generalized high/low hierarchy, is decidable. We also show that every finite poset labeled with elements of (where is the partition of induced by the generalized high/low hierarchy) can be embedded in preserving the labels. Note that no condition is imposed on the labels.

We prove several results about the existence of sparse sets complete (and hard) for Turing reductions on different settings and complexity classes over the real numbers.

This paper investigates a relationship among the accepting powers of deterministic, nondeterministic, and alternating one-pebble two-dimensional Turing machines, and shows that (i) nondeterminism are more powerful than determinism for o(log n) space-bounded one-pebble two-dimensional Turing machines whose input tapes are restricted to square ones, and (ii) alternation are more powerful than nondeterminism for f(m)+g(n) (resp., f(m) × g(n)) space-bounded one-pebble two-dimensional Turing machines, where f : N → N is an arbitrary monotonic nondecreasing funcion space-constractible by a deterministic one-pebble two-dimensional Turing machine, and g : N → N is an arbitrary function such that g(n) = o(log n) (resp., g(n) = o(log n/loglog n)).

Attribute grammars (AGs) are a formal technique for defining semantics of programming languages. Existing complexity proofs on the circularity problem of AGs are based on automata theory, such as writing pushdown acceptor and alternating Turing machines. They reduced the acceptance problems of above automata, which are exponential-time (EXPTIME) complete, to the AG circularity problem. These proofs thus show that the circularity problem is EXPTIME-hard, at least as hard as the most difficult problems in EXPTIME. However, none has given a proof for the EXPTIME-completeness of the problem. This paper first presents an alternating Turing machine for the circularity problem. The alternating Turing machine requires polynomial space. Thus, the circularity problem is in EXPTIME and is then EXPTIME-complete., Comment: 7 pages

We prove that ground reducibility is EXPTIME-complete in the general case. EXPTIME-hardness is proved by encoding the computations of an alternating Turing machine whose space is polynomially bounded. It is more difficult to show that ground reducibility belongs to DEXPTIME. We associate first an automaton with disequality constraints A/sub R,t/ to a rewrite system R and a term t. This automaton is deterministic and accepts a term u if and only if t is not ground reducible by R. The number of states of A/sub R,t/ is O(2/sup /spl par/R/spl par//spl times//spl par/t/spl par//) and the size of the constraints are polynomial in the size of R,t. Then we prove some new pumping lemmas, using a total ordering on the computations of the automaton. Thanks to these lemmas, we can give an upper bound to the number of distinct subtrees of a minimal successful computation of an automaton with disequality constraints. It follows that emptiness of such an automaton can be decided in time polynomial in the number of its states and exponential in the size of its constraints. Altogether, we get a simply exponential deterministic algorithm for ground reducibility.

We look at the hypothesis that all honest onto polynomial-time computable functions have a polynomial-time computable inverse. We show this hypothesis equivalent to several other complexity conjectures including:•In polynomial time, one can find accepting paths of nondeterministic polynomial-time Turing machines that accept Σ*.•Every total multivalued nondeterministic function has a polynomial-time computable refinement.•In polynomial time, one can compute satisfying assignments for any polynomial-time computable set of satisfiable formulae.•In polynomial time, one can convert the accepting computations of any nondeterministic Turing machine that accepts SAT to satisfying assignments. We compare these hypotheses with several other important complexity statements. We also examine the complexity of these statements where we only require a single bit instead of the entire inverse.

We state different versions of the P=?NP problem for infinite time Turing machines. It is observed that P≠NP collapses to the fact that there are analytic sets which are not Borel.

Let f and g be functions from N to N. We write f g to denote that there exists a constant c > 0 such that for all but finitely many n it holds that f (n) ≤ c(gcn) + cn. We say that f and g are equivalent if f g and g f . In [SBR] Sapir et al. conjecture that for all nondeterministic time functions T that are (n2) the square root of T is equivalent to the time function of a nondeterministic Turing machine. In this note we study this conjecture. We show that the deterministic version of this conjecture is false. For every rational number α, 0 < α < 1, there is a deterministic time function T = (n2) such that T α is not equivalent to any time function of a deterministic Turing machine.

The free-spectrum and g-spectrum functions of a variety V are defined as fV(n) = “the size of the free algebra on n generators in V” and gV(n) = “the number of non-isomorphic algebras in V generated by n or fewer elements”, for any positive integer n. Thus V is locally finite iff for each positive integer n, fV(n) is a positive integer (and consequently gV(n) is a positive integer). If V is locally finite, then we have

We study the easy certificate classes introduced by Hemaspaandra, Rothe, and Wechsung, with regard to the question of whether or not surjective one-way functions exist. This is a natural open question in worst-case cryptography. We show that the existence of partial one-way permutations can be characterized by separating P from the class of UP sets that, for all unambiguous polynomial-time Turing machines accepting them, always have easy (i.e., polynomial-time computable) certificates. This characterization expands results of Grollmann and Selman. We also establish characterizations of the existence of (partial and total) surjective poly-to-one one-way functions.