Infinite Computations Research Articles

Dense-Timed Petri Nets: Checking Zenoness, Token liveness and Boundedness

We consider Dense-Timed Petri Nets (TPN), an extension of Petri nets in which each token is equipped with a real-valued clock and where the semantics is lazy (i.e., enabled transitions need not fire; time can pass and disable transitions). We consider the following verification problems for TPNs. (i) Zenoness: whether there exists a zeno-computation from a given marking, i.e., an infinite computation which takes only a finite amount of time. We show decidability of zenoness for TPNs, thus solving an open problem from [Escrig et al.]. Furthermore, the related question if there exist arbitrarily fast computations from a given marking is also decidable. On the other hand, universal zenoness, i.e., the question if all infinite computations from a given marking are zeno, is undecidable. (ii) Token liveness: whether a token is alive in a marking, i.e., whether there is a computation from the marking which eventually consumes the token. We show decidability of the problem by reducing it to the coverability problem, which is decidable for TPNs. (iii) Boundedness: whether the size of the reachable markings is bounded. We consider two versions of the problem; namely semantic boundedness where only live tokens are taken into consideration in the markings, and syntactic boundedness where also dead tokens are considered. We show undecidability of semantic boundedness, while we prove that syntactic boundedness is decidable through an extension of the Karp-Miller algorithm.

Program termination analysis in polynomial time

A size-change termination algorithm takes as input abstract information about a program in the form of size-change graphs and uses it to determine whether any infinite computation would imply that some data decrease in size infinitely. Since such an infinite descent is presumed impossible, this proves program termination. The property of the graphs that implies program termination is called SCT. There are many examples of practical programs whose termination can be verified by creating size-change graphs and testing them for SCT.The size-change graph abstraction is useful because the graphs often carry sufficient information to deduce termination, and at the same time are simple enough to be analyzed automatically. However, there is a tradeoff between the completeness and efficiency of this analysis, and complete algorithms in the literature can easily be pushed to an exponential combinatorial search by certain patterns in the graph structures.We therefore propose a novel algorithm to detect common forms of parameter-descent behavior efficiently. Specifically, we target lexicographic descent, multiset descent, and min- and max-descent. Our algorithm makes it possible to verify practical instances of SCT while guarding against unwarranted combinatorial search. It has worst-case time complexity cubic in the input size, and its effectiveness is demonstrated empirically using a test suite of over 90 programs.

Sub-Computation Based Transition Predicate Abstraction

The transition predicate abstraction framework developed by Podelski, et al. (2005) captures size relations over state transitions which can be used to show infeasibility of certain program computations. In particular, general liveness properties (i.e., properties of infinite computations) can be verified by reducing the verification problem to one of fair termination and then proving that all (infinite) fair computations are infeasible. We present an extension of the algorithm by Podelski, et al. that can be used to improve the precision of transition predicate abstraction as well as speed up analysis time for programs with well-structured control-flow. The main key is to identify sub-computations that can be evaluated independently of their context. Efficiency is then readily improved by analyzing each sub-computation in turn, thus avoiding to reanalyze the effect of a given sub-computations for different contexts. Further, precision can be improved by using stronger methods for extracting summary information about a given sub-computation. We present two versions of the sub-computation based analysis: one for a non-parallel imperative language with loops and recursive procedures, serving as an introduction, and one for the extension of the non-parallel language to a parallel language with synchronous communication via statically named channels.

Randomness and halting probabilities

AbstractWe consider the question of randomness of the probability ΩU[X] that an optimal Turing machine U halts and outputs a string in a fixed set X. The main results are as follows:• ΩU[X] is random whenever X is Σn0-complete or Πn0-complete for some n ≥ 2.• However, for n ≥ 2, ΩU[X] is not n-random when X is Σn0 or Πn0. Nevertheless, there exists Δn+10 sets such that ΩU[X] is n-random.• There are Δ20 sets X such that ΩU[X] is rational. Also, for every n ≥ 1, there exists a set X which is Δn+10 and Σn0-hard such that ΩU[X] is not random.We also look at the range of ΩU as an operator. We prove that the set {ΩU[X]: X ⊆ 2≤ω} is a finite union of closed intervals. It follows that for any optimal machine U and any sufficiently small real r, there is a set X ⊆ 2≤ω recursive in ∅′ ⊕ r, such that ΩU[X] = r.The same questions are also considered in the context of infinite computations, and lead to similar results.

Using well-structured transition systems to decide divergence for catalytic P systems

P systems are a biologically inspired model introduced by Gheorghe Păun with the aim of representing the structure and the functioning of the cell. Since their introduction, several variants of P systems have been proposed and explored. We concentrate on the class of catalytic P systems without priorities associated with the rules. We show that the theory of Well-Structured Transition Systems can be used to decide the divergence problem (i.e. checking for the existence of an infinite computation) for such a class of P systems. As a corollary, we obtain an alternative proof of the nonuniversality of deterministic catalytic P systems, an open problem recently solved by Ibarra and Yen.

Iterative algebras at work

Iterative theories, which were introduced by Calvin Elgot, formalise potentially infinite computations as unique solutions of recursive equations. One of the main results of Elgot and his coauthors is a description of a free iterative theory as the theory of all rational trees. Their algebraic proof of this fact is extremely complicated. In our paper we show that by starting with ‘iterative algebras’, that is, algebras admitting a unique solution of all systems of flat recursive equations, a free iterative theory is obtained as the theory of free iterative algebras. The (coalgebraic) proof we present is dramatically simpler than the original algebraic one. Despite this, our result is much more general: we describe a free iterative theory on any finitary endofunctor of every locally presentable category $\cal{A}$.Reportedly, a blow from the welterweight boxer Norman Selby, also known as Kid McCoy, left one victim proclaiming,‘It's the real McCoy!’.

Kolmogorov complexity and set theoretical representations of integers

AbstractWe reconsider some classical natural semantics of integers (namely iterators of functions, cardinals of sets, index of equivalence relations) in the perspective of Kolmogorov complexity. To each such semantics one can attach a simple representation of integers that we suitably effectivize in order to develop an associated Kolmogorov theory. Such effectivizations are particular instances of a general notion of “self‐enumerated system” that we introduce in this paper. Our main result asserts that, with such effectivizations, Kolmogorov theory allows to quantitatively distinguish the underlying semantics. We characterize the families obtained by such effectivizations and prove that the associated Kolmogorov complexities constitute a hierarchy which coincides with that of Kolmogorov complexities defined via jump oracles and/or infinite computations (cf. [6]). This contrasts with the well‐known fact that usual Kolmogorov complexity does not depend (up to a constant) on the chosen arithmetic representation of integers, let it be in any base n ≥ 2 or in unary. Also, in a conceptual point of view, our result can be seen as a mean to measure the degree of abstraction of these diverse semantics. (© 2006 WILEY‐VCH Verlag GmbH & Co. KGaA, Weinheim)

Handling Liveness Properties in (ω-)Regular Model Checking

Since the topic emerged several years ago, work on regular model checking has mostly been devoted to the verification of state reachability and safety properties. Though it was known that liveness properties could also be checked within this framework, little has been done about working out the corresponding details, and experimentally evaluating the approach. This paper addresses these issues in the context of regular model checking based on the encoding of states by finite or infinite words. It works out the exact constructions to be used in both cases, and solves the problem resulting from the fact that infinite computations of unbounded configurations might never contain the same configuration twice, thus making cycle detection problematic. Several experiments showing the applicability of the approach were successfully conducted.

Kolmogorov complexities [formula omitted], [formula omitted] on computable partially ordered sets

We introduce a machine free mathematical framework to get a natural formalization of some general notions of infinite computation in the context of Kolmogorov complexity. Namely, the classes Max PR X → D and Max Rec X → D of functions X → D which are pointwise maximum of partial or total computable sequences of functions where D = ( D , < ) is some computable partially ordered set. The enumeration theorem and the invariance theorem always hold for Max PR X → D , leading to a variant K max D of Kolmogorov complexity. We characterize the orders D such that the enumeration theorem (resp. the invariance theorem) also holds for Max Rec X → D . It turns out that Max Rec X → D may satisfy the invariance theorem but not the enumeration theorem. Also, when Max Rec X → D satisfies the invariance theorem then the Kolmogorov complexities associated to Max Rec X → D and Max PR X → D are equal (up to a constant). Letting K min D = K max D rev , where D rev is the reverse order, we prove that either K min D = ct K max D = ct K D ( = ct is equality up to a constant) or K min D , K max D are ⩽ ct incomparable and < ct K D and > ct K ∅ ′ , D . We characterize the orders leading to each case. We also show that K min D , K max D cannot be both much smaller than K D at any point. These results are proved in a more general setting with two orders on D , one extending the other.

A Tool for the Syntactic Detection of Zeno-timelocks in Timed Automata

Timed automata are a very successful notation for specifying and verifying real-time systems, but timelocks can freely arise. These are counter-intuitive situations in which a specifier's description of a component automaton can inadvertently prevent time from passing beyond a certain point, possibly making the entire system stop. In particular, a zeno-timelock represents a situation where infinite computation is performed in a finite period of time. Zeno-timelocks are very hard to detect for real-time model checkers, e.g. UPPAAL and Kronos. We have developed a tool which can take an UPPAAL model as input and return a number of loops which can potentially cause zeno-timelocks. This tool implements an algorithm which refines a static verification approach introduced by Tripakis. We illustrate the use of this tool on a real-life case-study, the CSMA/CD protocol.

Random reals and possibly infinite computations Part I: Randomness in ∅′

AbstractUsing possibly infinite computations on universal monotone Turing machines, we prove Martin-Löf randomness in ∅′ of the probability that the output be in some set under complexity assumptions about .

On the verification of finite failure

In Gori [An abstract interpretation framework to reason on finite failure and other properties of finite and infinite computations, Theoret. Comput. Sci. 290(1) (2003) 863–936] a new fixpoint semantics which correctly models finite failure has been defined. This semantics is And-compositional, compositional w.r.t. instantiation and is based on a co-continuous operator. Based on this fixpoint semantics a new inductive method able to verify a program w.r.t. the property of finite failure can be defined. In this paper we show how Ferrand's approach, using both a least fixpoint and greatest fixpoint semantics, can be adapted to finite failure. The verification method is not effective. Therefore, we consider an approximation from above and an approximation from below of our semantics, which give two different finite approximations. These approximations are used for effective program verification.

General Recursion via Coinductive Types

A fertile field of research in theoretical computer science investigates the representation of general recursive functions in intensional type theories. Among the most successful approaches are: the use of wellfounded relations, implementation of operational semantics, formalization of domain theory, and inductive definition of domain predicates. Here, a different solution is proposed: exploiting coinductive types to model infinite computations. To every type A we associate a type of partial elements Partial(A), coinductively generated by two constructors: the first, return(a) just returns an element a:A; the second, step(x), adds a computation step to a recursive element x:Partial(A). We show how this simple device is sufficient to formalize all recursive functions between two given types. It allows the definition of fixed points of finitary, that is, continuous, operators. We will compare this approach to different ones from the literature. Finally, we mention that the formalization, with appropriate structural maps, defines a strong monad.

Kolmogorov Complexity for Possibly Infinite Computations

In this paper we study the Kolmogorov complexity for non-effective computations, that is, either halting or non-halting computations on Turing machines. This complexity function is defined as the length of the shortest input that produce a desired output via a possibly non-halting computation. Clearly this function gives a lower bound of the classical Kolmogorov complexity. In particular, if the machine is allowed to overwrite its output, this complexity coincides with the classical Kolmogorov complexity for halting computations relative to the first jump of the halting problem. However, on machines that cannot erase their output --called monotone machines--, we prove that our complexity for non effective computations and the classical Kolmogorov complexity separate as much as we want. We also consider the prefix-free complexity for possibly infinite computations. We study several properties of the graph of these complexity functions and specially their oscillations with respect to the complexities for effective computations.

New Evaluation Commands for Maude Within Full Maude

Maude is able to deal with infinite data structures and avoid infinite computations by using strategy annotations. However, they can eventually make the computation of the normal form(s) of some input expressions impossible. We have used Full Maude to implement two new commands norm and eval which furnish Maude with the ability to compute (constructor) normal forms of initial expressions even when the use of strategy annotations together with the built-in computation strategy of Maude is not able to obtain them. These commands have been integrated into Full Maude, making them available inside the programming environment like any other of its commands.

Performance comparison of search-based simulation optimisation algorithms for operations scheduling

This paper discusses the use of meta-heuristics coupled with discrete event simulations of various manufacturing systems to find the optimal operation schedules. Two search-based heuristic algorithms, OptQuest® (based on scatter search, tabu search and neural networks) and SimRunner® (based on genetic algorithm), are compared with respect to the quality of results and the computational time for a family of manufacturing system problems. The set of manufacturing systems configurations have been defined using the factors type of (flow shop and job shop), number of part types and number of machines. This family of problems is analysed based on the stochasticity of data, which is, using either deterministic or stochastic data for part inter-arrival times and processing times. A structured experiment has been conducted to test the responses of the two algorithms in optimising two different objective functions, maximising throughput rate and minimising percentage of tardy jobs. Arena® embedding OptQuest® and ProModel® embedding SimRunner® have been used in this research. Significant validation efforts have been made to ensure that simulation models built in Arena® and ProModel® are identical so that the performance difference only accrues from the heuristics. Evidences have been found to indicate that SimRunner® produced better results when the computation time is limited; however, OptQuest® produced comparable, sometimes superior results, when allowed infinite computation time.

Program Size Complexity for Possibly Infinite Computations

We define a program size complexity function $H^\infty$ as a variant of the prefix-free Kolmogorov complexity, based on Turing monotone machines performing possibly unending computations. We consider definitions of randomness and triviality for sequences in ${\{0,1\}}^\omega$ relative to the $H^\infty$ complexity. We prove that the classes of Martin-Lof random sequences and $H^\infty$-random sequences coincide and that the $H^\infty$-trivial sequences are exactly the recursive ones. We also study some properties of $H^\infty$ and compare it with other complexity functions. In particular, $H^\infty$ is different from $H^A$, the prefix-free complexity of monotone machines with oracle A.

From Iterative Algebras to Iterative Theories: (Extended Abstract)

Iterative theories introduced by Calvin Elgot formalize potentially infinite computations as solutions of recursive equations. One of the main results of Elgot and his coauthors is a description of a free iterative theory as the theory of all rational trees. Their algebraic proof of this fact is extremely complicated. In our paper we show that by starting with “iterative algebras”, i. e., algebras admitting a unique solution of all systems of flat recursive equations, a free iterative theory is obtained as the theory of free iterative algebras. The (coalgebraic) proof we present is dramatically simpler than the original algebraic one. And our result is, nevertheless, much more general: we describe a free iterative theory on any finitary endofunctor of every locally presentable category A. This allows us, e. g., to consider iterative algebras over any equationally specified class A of finitary algebras.

Relating models of backtracking

Past attempts to relate two well-known models of backtracking computation have met with only limited success. We relate these two models using logical relations. We accommodate higher-order values and infinite computations. We also provide an operational semantics, and we prove it adequate for both models.

Recursion and topology on 2 ⩽ ω for possibly infinite computations

In the context of possibly infinite computations yielding finite or infinite (binary) outputs, the space 2 ⩽ω = 2 ∗ ∪ 2 ω appears to be one of the most fundamental spaces in Computer Science. Though underconsidered, next to 2 ω , this space can be viewed (Section 3.5.2) as the simplest compact space native to computer science. In this paper we study some of its properties involving topology and computability. Though 2 ⩽ ω can be considered as a computable metric space in the sense of computable analysis, a direct and self-contained study, based on its peculiar properties related to words, is much illuminating. It is well known that computability for maps 2 ω → 2 ω reduces to continuity with recursive modulus of continuity. With 2 ⩽ ω , things get less simple. Maps 2 ω → 2 ⩽ω or 2 ⩽ω → 2 ⩽ω induced by input/output behaviours of Turing machines on finite or infinite words—which we call semicomputable maps—are not necessarily continuous but merely lower semicontinuous with respect to the prefix partial ordering on 2 ⩽ ω . Continuity asks for a stronger notion of computability. We prove for (semi)continuous and (semi)computable maps F : I→ O with I, O∈{2 ω,2 ⩽ω} a detailed representation theorem (Theorem 81) via functions f : 2 ∗ → 2 ∗ following two approaches: bottom-up from f to F and top-down from F to f.