Results 1 
5 of
5
Resource Control Graphs
"... Resource Control Graphs are an abstract representation of programs. Each state of the program is abstracted by its size, and each instruction is abstracted by the effects it has on the state size whenever it is executed. The abstractions of instruction effects are then used as weights on the arcs of ..."
Abstract

Cited by 2 (0 self)
 Add to MetaCart
Resource Control Graphs are an abstract representation of programs. Each state of the program is abstracted by its size, and each instruction is abstracted by the effects it has on the state size whenever it is executed. The abstractions of instruction effects are then used as weights on the arcs of a program’s Control Flow Graph. Termination is proved by finding decreases in a wellfounded order on statesize, in line with other termination analyses, resulting in proofs similar in spirit to those produced by Size Change Termination analysis. However, the size of states may also be used to measure the amount of space consumed by the program at each point of execution. This leads to an alternative characterisation of the Non Size Increasing programs, i.e. of programs that can compute without allocating new memory. This new tool is able to encompass several existing analyses and similarities with other studies suggest that even more analyses might be expressable in this framework, thus giving hopes for a generic tool for studying programs.
D.2.8 [Software Engineering]: Metrics—complexity measures,
"... f(0, y) = g(y) f(x + 1, y) = h(x, y, f(j1(x), y),..., f(jk(x), y) where g, h, j1,..., jk are primitive recursive and ji(x) ≤ x for i ∈ {1,..., k} , are themselves primitive recursive. A similar remark holds for recursion with parameter substituhal00642731, ..."
Abstract
 Add to MetaCart
f(0, y) = g(y) f(x + 1, y) = h(x, y, f(j1(x), y),..., f(jk(x), y) where g, h, j1,..., jk are primitive recursive and ji(x) ≤ x for i ∈ {1,..., k} , are themselves primitive recursive. A similar remark holds for recursion with parameter substituhal00642731,
Formalizing Turing Machines
"... Abstract. We discuss the formalization, in the Matita Theorem Prover, of a few, basic results on Turing Machines, up to the existence of a (certified) Universal Machine. The work is meant to be a preliminary step towards the creation of a formal repository in Complexity Theory, and is a small piece ..."
Abstract
 Add to MetaCart
Abstract. We discuss the formalization, in the Matita Theorem Prover, of a few, basic results on Turing Machines, up to the existence of a (certified) Universal Machine. 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 Reverse Complexity program, aiming to a comfortable, machine independent axiomatization of the field. 1
Licensed under a Creative Commons Attribution License
"... is essentially always possible to find a program solving any decision problem a factor of 2 faster. This result is a classical theorem in computing, but also one of the most debated. The main ingredient of the typical proof of the linear speedup theorem is tape compression, where a fast machine is c ..."
Abstract
 Add to MetaCart
is essentially always possible to find a program solving any decision problem a factor of 2 faster. This result is a classical theorem in computing, but also one of the most debated. The main ingredient of the typical proof of the linear speedup theorem is tape compression, where a fast machine is constructed with tape alphabet or number of tapes far greater than that of the original machine. In this paper, we prove that limiting Turing machines to a fixed alphabet and a fixed number of tapes rules out linear speedup. Specifically, we describe a language that can be recognized in linear time (e. g., 1.51n), and provide a proof, based on Kolmogorov complexity, that the computation cannot be sped up (e. g., below 1.49n). Without the tape and alphabet limitation, the linear speedup theorem does hold and yields machines of time complexity of the form (1 + ε)n for arbitrarily small ε> 0. Earlier results negating linear speedup in alternative models of computation have often been based on the existence of very efficient universal machines. In the vernacular of programming language theory: These models have very efficient selfinterpreters. As the second contribution of this paper, we define a class, PICSTI, of computation models that exactly captures this property, and we disprove the Linear Speedup Theorem for every model in this class, thus generalizing all similar, modelspecific proofs.
Generalizations of Rice’s Theorem, Applicable to Executable and NonExecutable Formalisms
"... We formulate and prove two Ricelike theorems that characterize limitations on nameability of properties within a given naming scheme for partial functions. Such a naming scheme can, but need not be, an executable formalism. A programming language is an example of an executable naming scheme, where ..."
Abstract
 Add to MetaCart
We formulate and prove two Ricelike theorems that characterize limitations on nameability of properties within a given naming scheme for partial functions. Such a naming scheme can, but need not be, an executable formalism. A programming language is an example of an executable naming scheme, where the program text names the partial function it implements. Halting is an example of a property that is not nameable in that naming scheme. The proofs reveal requirements on the naming scheme to make the characterization work. Universal programming languages satisfy these requirements, but also other formalisms can satisfy them. We present some nonuniversal programming languages and a nonexecutable specification language satisfying these requirements. Our theorems have Turing’s wellknown Halting Theorem and Rice’s Theorem as special cases, by applying them to a universal programming language or Turing Machines as naming scheme. Thus, our proofs separate the nature of the naming scheme (which can, but need not, coincide with computability) from the diagonal argument. This sheds further light on how far reaching and simple the ‘diagonal ’ argument is in itself. 1