Infinite Computations Research Articles

Infinite vs. finite size-bounded randomized computations

Randomized computations can be very powerful with respect to space complexity, e.g., for logarithmic space, LasVegas is equivalent to nondeterminism. This power depends on the possibility of infinite computations, however, it is an open question if they are necessary. We answer this question for rotating finite automata (rfas) and sweeping finite automata (sfas). We show that LasVegas rfas (sfas) allowing infinite computations, although only with probability 0, can be exponentially smaller than LasVegas rfas (sfas) forbidding them. In particular, we show that even rfas (sfas) with linear expected running time may require exponentially more states than rfas (sfas) running in exponential time. We also strengthen this result, showing that the restriction on time cannot be traded for the more powerful bounded-error randomization. To prove our results, we introduce a technique for proving lower bounds on size of rfas (sfas) that generalizes the notion of generic strings discovered by M. Sipser.

Infinite probability computation by cyclic explanation graphs

AbstractTabling in logic programming has been used to eliminate redundant computation and also to stop infinite loop. In this paper we investigate another possibility of tabling, i.e. to compute an infinite sum of probabilities for probabilistic logic programs. Using PRISM, a logic-based probabilistic modeling language with a tabling mechanism, we generalize prefix probability computation for probabilistic context-free grammars (PCFGs) to probabilistic logic programs. Given a top-goal, we search for all proofs with tabling and obtain an explanation graph which compresses them and may be cyclic. We then convert the explanation graph to a set of linear probability equations and solve them by matrix operation. The solution gives us the probability of the top-goal, which, in nature, is an infinite sum of probabilities. Our general approach to prefix probability computation through tabling not only allows to deal with non-probabilistic context-free grammars such as probabilistic left-corner grammars but has applications such as plan recognition and probabilistic model checking and makes it possible to compute probability for probabilistic models describing cyclic relations.

An abstraction-refinement framework for trigger querying

Trigger querying is the problem of finding, given a system M and an LTL formula φ, the set of scenarios that trigger φ in M; that is, the language L of finite computations of M such that all infinite computations that have a prefix in L continue with a suffix that satisfies φ. Trigger querying significantly extends query checking, which seeks propositional solutions, and is an extremely useful methodology for system exploration and understanding. The weakness of trigger querying lies in the fact that the size of the solution is linear in the size of the system. For trigger querying to become feasible in practice, we must offer solutions to cope with systems of big, and possibly infinite, state spaces. In this paper we describe an abstraction-refinement framework for trigger querying. Instead of reasoning about the system M, we reason about an abstraction of it and return to the user two languages that under- and over-approximate the language L of computations that trigger φ in M. We describe an automata-theoretic approach for refining and reducing the gap between the approximations and show how, unlike classical counterexample-based refinement approaches, here it is possible to symbolically handle batches of counterexamples. We show that our framework is robust and can be applied also for classical query checking as well as variants and extensions of trigger querying.

Algebras for iteration and infinite computations

We give axioms for an operation that describes iteration in various relational models of computations. The models differ in their treatment of finite, infinite and aborting executions, covering partial, total and general correctness and extensions thereof. Based on the common axioms we derive separation, refinement and program transformation results hitherto known from particular models, henceforth recognised to hold in many different models. We introduce a new model that independently describes the finite, infinite and aborting executions of a computation, and axiomatise an operation that extracts the infinite executions in this model and others. From these unifying axioms we derive explicit representations for recursion and iteration. We show that also the new model is an instance of our general theory of iteration. All results are verified in Isabelle heavily using automated theorem provers.

On termination and invariance for faulty channel machines

Abstract A channel machine consists of a finite controller together with several fifo channels; the controller can read messages from the head of a channel and write messages to the tail of a channel. In this paper we focus on channel machines with insertion errors , i.e., machines in whose channels messages can spontaneously appear. We consider the invariance problem: does a given insertion channel machine have an infinite computation all of whose configurations satisfy a given predicate? We show that this problem is primitive-recursive if the predicate is closed under message losses. We also give a non-elementary lower bound for the invariance problem under this restriction. Finally, using the previous result, we show that the satisfiability problem for the safety fragment of Metric Temporal Logic is non-elementary.

Model checking time-dependent system specifications using Time Stream Petri Nets and Uppaal

This paper describes an approach to modeling and analysis of time-dependent system specifications which is based on the Time Stream Petri Nets (TSPNs) formalism. The work argues that although TSPNs were originally proposed for modeling multimedia/hypermedia systems, they are well suited for expressing timing constraints in general time-dependent systems. The approach is assisted by some developed tools based on model checking in terms of Uppaal timed automata, which permit behavioural analysis and in particular schedulability analysis of task executions in real-time specifications. Property analysis rests on the construction of a (hopefully finite) zone state graph of a TSPN model and its efficient traversal by Uppaal verifier, which in turn represents an effective approach for dealing with infinite computations in a compact way. The paper introduces the TSPN formalism and focuses on the implemented structural translation onto Uppaal which is assisted by a library of reusable template processes. The modeling/analysis techniques are demonstrated by two examples. The first example deals with project management, i.e. the exhaustive analysis of general CPM/PERT project models where an activity duration is expressed by a time interval. The second example is related to a thoroughly analysis of the temporal behaviour of a complex embedded real-time system with timing constraints. An indication of on-going and future work is, finally, given in the conclusions. Soundness of the structural translation is shown by a formal proof reported in appendix.

Reasoning about actions with Temporal Answer Sets

AbstractIn this paper, we combine Answer Set Programming (ASP) with Dynamic Linear Time Temporal Logic (DLTL) to define a temporal logic programming language for reasoning about complex actions and infinite computations. DLTL extends propositional temporal logic of linear time with regular programs of propositional dynamic logic, which are used for indexing temporal modalities. The action language allows general DLTL formulas to be included in domain descriptions to constrain the space of possible extensions. We introduce a notion of Temporal Answer Set for domain descriptions, based on the usual notion of Answer Set. Also, we provide a translation of domain descriptions into standard ASP and use Bounded Model Checking (BMC) techniques for the verification of DLTL constraints.

A Dynamic Approach on Quickly Predicting Non-Termination of Logic Program of Security Protocol

Based on the dynamic approach to characterizing termination of generic logic program,a dynamic approach to characterizing termination of solved-form fixpoint is researched in this paper,and a sufficient condition of non-termination of solved-form fixpoint of the extended Horn logic model of security protocol is presented.Based on this condition,an approach is represented to predict non-termination of computation of solved-form fixpoint.This approach can predict the non-termination of computing fixpoint by checking new generated rules,and localize the solved-form rules in the extended Horn logic model which cause infinite computations of solved-form fixpoint.The non-termination prediction results will provide the criteria for choosing different verification methods of security protocols,such as accurate methods and abstract methods.The experiment results show the effectiveness of the prediction algorithms.

Confluence Results for a Quantum Lambda Calculus with Measurements

A strong confluence result for Q*, a quantum λ-calculus with measurements, is proved. More precisely, confluence is shown to hold both for finite and infinite computations. The technique used in the confluence proof is syntactical but innovative. This makes Q* different from similar quantum lambda calculi, which are either measurement-free or provided with a reduction strategy.

Preface to the Special Issue Unconventional Computing 2008

This special issue contains five articles selected from the papers presented at the 7th International Conference on Unconventional Computing, UC 2008, held in Vienna, Austria on 25–28 August 2008. ‘‘Unconventional Computing’’, http://www.cs.auckland.ac.nz/ research/groups/CDMTCS/conferences/uc/uc.html, is the primary international conference dedicated to all aspects of unconventional computing, theory as well as experiments and applications. Giorgio Delzanno and Laurent Van Begin study computational properties of extended P systems that model creation, dissolution, fusion, and cloning of membranes in their paper ‘‘On the verification of membrane systems with dynamic structure’’. The paper ‘‘Quantum security in wireless sensor networks’’, by Naya Nagy, Marius Nagy and Selim Akl, proposes a new security solution based on quantum cryptography. Turlough Neary proves, in the paper ‘‘On the computational complexity of spiking neural P systems’’, that no spiking neural P system (with a constant number of neurons) is capable of simulating Turing machines with less than exponential time and space overheads. He also constructs a universal extended spiking neural P system with exhaustive use of rules and 10 neurons that simulates Turing machines in linear time. In the paper ‘‘Output concepts for accelerated Turing machines’’ Petrus Potgieter and Elemer Rosinger study the problem of rigorously defining the output of the infinite computation performed by an accelerated Turing machine. Linmin Yang, Yong Wang and Zhe Dang study a new computation paradigm, inspired by P systems, defined over a multiset of communicating objects in their paper ‘‘Automata and processes of multisets of communicating objects’’. They prove that the Presburger

Decidability properties for fragments of CHR

AbstractWe study the decidability of termination for two CHR dialects which, similarly to the Datalog like languages, are defined by using a signature which does not allow function symbols (of arity > 0). Both languages allow the use of the = built-in in the body of rules, thus are built on a host language that supports unification. However each imposes one further restriction. The first CHR dialect allows only range-restricted rules, that is, it does not allow the use of variables in the body or in the guard of a rule if they do not appear in the head. We show that the existence of an infinite computation is decidable for this dialect. The second dialect instead limits the number of atoms in the head of rules to one. We prove that in this case, the existence of a terminating computation is decidable. These results show that both dialects are strictly less expressive1 than Turing Machines. It is worth noting that the language (without function symbols) without these restrictions is as expressive as Turing Machines.

The Complexity of Infinite Computations In Models of Set Theory

We prove the following surprising result: there exist a 1-counter B\"uchi automaton and a 2-tape B\"uchi automaton such that the \omega-language of the first and the infinitary rational relation of the second in one model of ZFC are \pi_2^0-sets, while in a different model of ZFC both are analytic but non Borel sets. This shows that the topological complexity of an \omega-language accepted by a 1-counter B\"uchi automaton or of an infinitary rational relation accepted by a 2-tape B\"uchi automaton is not determined by the axiomatic system ZFC. We show that a similar result holds for the class of languages of infinite pictures which are recognized by B\"uchi tiling systems. We infer from the proof of the above results an improvement of the lower bound of some decision problems recently studied by the author.

From index sets to randomness in ∅n: random reals and possibly infinite computations part II

AbstractWe obtain a large class of significant examples of n-random reals (i.e., Martin-Löf random in oracle ∅(n−1)) à la Chaitin. Any such real is defined as the probability that a universal monotone Turing machine performing possibly infinite computations on infinite (resp. finite large enough, resp. finite self-delimited) inputs produces an output in a given set . In particular, we develop methods to transfer many-one completeness results of index sets to n-randomness of associated probabilities.

Deciding branching time properties for asynchronous programs

Asynchronous programming is a paradigm that supports asynchronous function calls in addition to synchronous function calls. Programs in such a setting can be modeled by automata with counters that keep track of the number of pending asynchronous calls for each function, as well as a call stack for synchronous recursive computation. These programs have the restriction that an asynchronous call is processed only when the call stack is empty. The decidability of the control state reachability problem for such systems was recently established. In this paper, we consider the problems of checking other branching time properties for such systems. Specifically we consider the following problems — termination, which asks if there is an infinite (non-terminating) computation exhibited by the system; control state maintainability, which asks if there is a maximal execution of the system, where all the state visited lie in some “good” set; whether the system can be simulated by a given finite state system; and whether the system can simulate a given finite state system. We present decision algorithms for all these problems.

Infinite Computations and a Hierarchy in 3 Reconsidered

In this note, we reconsider the results in Rovan and Steskal (2007, Vol. 4497 of Lecture Notes in Computer Science, pp. 660–669, Springer) concerning TMDC (Display Turing Machines with Control) with Chomsky like control language. We shall show that, under the given assumptions, various degrees of the control complexity do not give rise to a hierarchy of language families, thus correcting an error in Rovan and Steskal (2007, Vol. 4497 of Lecture Notes in Computer Science, pp. 660–669, Springer).

Wadge Reducibility and Infinite Computations

This is a survey of results about Wadge reducibility in some spaces and its relation to the study of infinite (non-terminating) computations. We also discuss the related techniques and directions of future research.

Fine hierarchies and m-reducibilities in theoretical computer science

This is a survey of results about versions of fine hierarchies and many-one reducibilities that appear in different parts of theoretical computer science. These notions and related techniques play a crucial role in understanding complexity of finite and infinite computations. We try not only to present the corresponding notions and facts from the particular fields but also to identify the unifying notions, techniques and ideas.

A taste of functional programming — 2

Functional programming has its roots in Alonzo Church’s lambda calculus. In the first part1 of this article, we explored some basic notions of functional programming using the language Haskell. We now examine some more advanced concepts, including polymorphism, infinite data types and computations, and user-defined data types.

Cooperative combinatorial optimization: Evolutionary computation case study

This paper presents a formalization of the notion of cooperation and competition of multiple systems that work toward a common optimization goal of the population using evolutionary computation techniques. It is proved that evolutionary algorithms are more expressive than conventional recursive algorithms, such as Turing machines. Three classes of evolutionary computations are introduced and studied: bounded finite, unbounded finite, and infinite computations. Universal evolutionary algorithms are constructed. Such properties of evolutionary algorithms as completeness, optimality, and search decidability are examined. A natural extension of evolutionary Turing machine (ETM) model is proposed to properly reflect phenomena of cooperation and competition in the whole population.

Infinite Computation in the Equivalent Transformation Model

There are many logic programs that do not terminate but perform useful computation in some sense. The usual theory of logic programming adopts least fixpoints to define the meaning of programs, which fails to capture the intended meaning of infinite computation. To give an appropriate sense to useful infinite computation, the theory of logic programming has adopted greatest fixpoints in place of least fixpoints. However, this solution developed in logic paradigm can not explain finite and infinite computation in a unified manner. This paper proposes a new approach to infinite computation based on the equivalent transformation paradigm, where infinite computation is regarded as repeated equivalent transformations and is given appropriate sense in the same way as the usual finite computation.