Results 1  10
of
12
A Flow Calculus of mwpBounds for Complexity Analysis
"... We present a method for certifying that the values computed by an imperative program will be bounded by polynomials in the program’s inputs. To this end, we introduce mwpmatrices and define a semantic relation  = C: M where C is a program and M is an mwpmatrix. It follows straightforwardly from o ..."
Abstract

Cited by 4 (3 self)
 Add to MetaCart
We present a method for certifying that the values computed by an imperative program will be bounded by polynomials in the program’s inputs. To this end, we introduce mwpmatrices and define a semantic relation  = C: M where C is a program and M is an mwpmatrix. It follows straightforwardly from our definitions that there exists M such that  = C:M holds iff every value computed by C is bounded by a polynomial in the inputs. Furthermore, we provide a syntactical proof calculus and define the relation ⊢ C:M to hold iff there exists a derivation in the calculus where C:M is the bottom line. We prove that ⊢ C:M implies  = C:M. By means of exhaustive proof search, an algorithm can decide if there exists M such that the relation ⊢ C:M holds, and thus, our results yield a computational method. Categories and Subject Descriptors: D.2.4 [Software engineering]: Software/Program Verification; F.2.0 [Analysis of algorithms and problem complexity]: General; F.3.1 [Logics and meanings of programs]: Specifying and Verifying and Reasoning about Programs
On Decidable GrowthRate Properties of Imperative Programs (invited talk paper)
"... In 2008, BenAmram, Jones and Kristiansen showed that for a simple “core ” programming language— an imperative language with bounded loops, and arithmetics limited to addition and multiplication— it is possible to decide precisely whether a program has certain growthrate properties, namely polynomi ..."
Abstract

Cited by 3 (2 self)
 Add to MetaCart
In 2008, BenAmram, Jones and Kristiansen showed that for a simple “core ” programming language— an imperative language with bounded loops, and arithmetics limited to addition and multiplication— it is possible to decide precisely whether a program has certain growthrate properties, namely polynomial (or linear) bounds on computed values, or on the running time. This work emphasized the role of the core language in mitigating the notorious undecidability of program properties, so that one deals with decidable problems, while allowing the application of the technique to programs in a more realistic language. This is done by overapproximating the semantics of the concrete program. A natural and intriguing problem was whether more elements can be added to the core language, improving the precision of approximation, while keeping the growthrate properties decidable. In particular, the method presented could not handle a command that resets a variable to zero. This paper shows how to handle resets. The analysis is given in a logical style (proof rules), and the complexity of the algorithm is shown to be PSPACE. The problem is shown PSPACEcomplete (in contrast, without resets, the problem was PTIME). The analysis algorithm evolved from the previous solution in an interesting way: focus was shifted from proving a bound to disproving it, and the algorithm works topdown rather than bottomup. 1
Linear, Polynomial or Exponential? Complexity Inference in Polynomial Time (Extended Abstract)
"... Abstract. We present a new method for inferring complexity properties for imperative programs with bounded loops. The properties handled are: polynomial (or linear) boundedness of computed values, as a function of the input; and similarly for the running time. It is well known that complexity proper ..."
Abstract

Cited by 3 (1 self)
 Add to MetaCart
Abstract. We present a new method for inferring complexity properties for imperative programs with bounded loops. The properties handled are: polynomial (or linear) boundedness of computed values, as a function of the input; and similarly for the running time. It is well known that complexity properties are undecidable for a Turingcomplete programming language. Much work in program analysis overcomes this obstacle by relaxing the correctness notion: one does not ask for an algorithm that correctly decides whether the property of interest holds or not, but only for “yes ” answers to be sound. In contrast, we reshaped the problem by defining a “core ” programming language that is Turingincomplete, but strong enough to model real programs of interest. For this language, our method is the first to give a certain answer; in other words, our inference is both sound and complete. The essence of the method is that every command is assigned a “complexity certificate”, which is a concise specification of dependencies of output values on input. These certificates are produced by inference rules that are compositional and efficiently computable. The approach is inspired by previous work by Niggl and Wunderlich and by Jones and Kristiansen, but use a novel, more expressive kind of certificates.
Extracting Witnesses from Proofs of Knowledge in the Random Oracle Model
, 2001
"... We prove that a 3move interactive proof system with the special soundness property made noninteractive by applying the FiatShamir heuristic is almost a noninteractive proof of knowledge in the random oracle model. In an application of the result we demonstrate that the Damg˚ardJurik voting sche ..."
Abstract

Cited by 2 (0 self)
 Add to MetaCart
We prove that a 3move interactive proof system with the special soundness property made noninteractive by applying the FiatShamir heuristic is almost a noninteractive proof of knowledge in the random oracle model. In an application of the result we demonstrate that the Damg˚ardJurik voting scheme based on homomorphic threshold encryption is secure against a nonadaptive adversary according to Canetti’s definition of multiparty computation security. 1
Static Complexity Analysis of Programs
"... In this paper we explicate the proof calculus introduced in Kristiansen & Jones [10]. We consider an imperative programming language that is natural, in the sense that it is an essential fragment of many popular reallife programming languages, and powerful, in the sense that it yields full Turi ..."
Abstract
 Add to MetaCart
In this paper we explicate the proof calculus introduced in Kristiansen & Jones [10]. We consider an imperative programming language that is natural, in the sense that it is an essential fragment of many popular reallife programming languages, and powerful, in the sense that it yields full Turing computability. By doing derivations in our calculus, we are able to establish useful information about the computational complexity of programs. Related Work: Our proof calculus is based on an analysis of the relationship between the resource requirements of a computation and the way data might flow during the computation. This analysis extends and refines the insights acquired by research as done by Bellantoni & Cook ([2] normal and safe variables), Leivant ([16] ramification), and in particular, Kristiansen & Niggl ([11, 12] measures). The insight that there is a relationship between the absence and presence of successorlike functions and the computational complexity of a program is a part of the foundation of our calculus, see e.g., Jones [6, 7], Kristiansen & Voda [13, 14], and Kristiansen [9]. Even if our research builds on, and is comparable to, the research discussed above, it has a different emphasis, e.g., we are not aiming at implicit characterisations
February 1, 2013 12:8 WSPC/INSTRUCTION FILE undecidableR2 International Journal of Foundations of Computer Science c ○ World Scientific Publishing Company ON THE EDGE OF DECIDABILITY IN COMPLEXITY ANALYSIS OF LOOP PROGRAMS ∗
, 2010
"... We investigate the decidability of the feasibility problem for imperative programs with bounded loops. A program is called feasible if all values it computes are polynomially bounded in terms of the input. The feasibility problem is representative of a group of related properties, like that of polyn ..."
Abstract
 Add to MetaCart
We investigate the decidability of the feasibility problem for imperative programs with bounded loops. A program is called feasible if all values it computes are polynomially bounded in terms of the input. The feasibility problem is representative of a group of related properties, like that of polynomial time complexity. It is well known that such properties are undecidable for a Turingcomplete programming language. They may be decidable, however, for languages that are not Turingcomplete. But if these languages are expressive enough, they do pose a challenge for analysis. We are interested in tracing the edge of decidability for the feasibility problem and similar problems. In previous work, we proved that such problems are decidable for a language where loops are bounded but indefinite (that is, the loops may exit before completing the given iteration count). In this paper, we consider definite loops. A second language feature that we vary, is the kind of assignment statements. With ordinary assignment, we prove undecidability of a very tiny language fragment. We also prove undecidability with lossy assignment (that is, assignments where the modified variable may receive any value bounded by the given expression, even zero). But we prove decidability with max
Trusted
"... Abstract. We define a translation of Meyer and Ritchie’s Loop language into a subsystem of Gödel’s system T (with product types). Then we show that this translation actually provides a lockstep simulation if a callbyvalue strategy is assumed for system T. Some generalizations and possible applicat ..."
Abstract
 Add to MetaCart
Abstract. We define a translation of Meyer and Ritchie’s Loop language into a subsystem of Gödel’s system T (with product types). Then we show that this translation actually provides a lockstep simulation if a callbyvalue strategy is assumed for system T. Some generalizations and possible applications are discussed. 1.
On the Edge of Decidability in Complexity Analysis of Loop Programs
, 2011
"... We investigate the decidability of the feasibility problem for imperative programs with bounded loops. A program is called feasible if all values it computes are polynomially bounded in terms of the input. The feasibility problem is representative of a group of related properties, like that of polyn ..."
Abstract
 Add to MetaCart
We investigate the decidability of the feasibility problem for imperative programs with bounded loops. A program is called feasible if all values it computes are polynomially bounded in terms of the input. The feasibility problem is representative of a group of related properties, like that of polynomial time complexity. It is well known that such properties are undecidable for a Turingcomplete programming language. They may be decidable, however, for fragmentary languages, that are Turingincomplete. But if such fragments are expressive enough, they do pose a challenge for analysis. We are interested in tracing the edge of decidability for the feasibility problem and similar problems. In previous work, we proved that such problems are decidable for an interesting fragment where loops were indefinite (that is, may exit before completing the given iteration count). In this paper, we consider definite loops. A second language feature that we vary, is the kind of assignment statements. With ordinary assignment, we prove undecidability of a very tiny language fragment. We also prove undecidability with weak assignment, where the modified variable may receive any value bounded by the given expression, even zero. But we prove decidability with max assignments, where the assigned variable never decreases its value.
Both can be found at the ENTCS Macro Home Page. The Garland Measure and Computational Complexity of Stack Programs
"... Replace this file withprentcsmacro.sty for your meeting, ..."