Results 1  10
of
18
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 6 (3 self)
 Add to MetaCart
(Show Context)
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
Programming Languages Capturing Complexity Classes
 NORDIC JOURNAL OF COMPUTING
, 2005
"... We investigate an imperative and a functional programming language. The computational power of fragments of these languages induce two hierarchies of complexity classes. Our first main theorem says that these hierarchies match, level by level, a complexitytheoretic alternating spacetime hierarc ..."
Abstract

Cited by 5 (2 self)
 Add to MetaCart
We investigate an imperative and a functional programming language. The computational power of fragments of these languages induce two hierarchies of complexity classes. Our first main theorem says that these hierarchies match, level by level, a complexitytheoretic alternating spacetime hierarchy known from the literature. Our second main theorems says that a slightly different complexitytheoretic hierarchy (the GoerdtSeidl hierarchy) also can be captured by hierarchies induced by fragments of the programming languages. Well known complexity classes like logspace, linspace, p, pspace, etc., occur in the hierarchies.
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 5 (3 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 5 (1 self)
 Add to MetaCart
(Show Context)
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 3 (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
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

Cited by 1 (0 self)
 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.
UvADARE (Digital Academic Repository) Instruction Sequence Based Nonuniform Complexity Classes
, 2014
"... Instruction sequence based nonuniform complexity classes Bergstra, J.A.; Middelburg, C.A. General rights It is not permitted to download or to forward/distribute the text or part of it without the consent of the author(s) and/or copyright holder(s), other than for strictly personal, individual us ..."
Abstract
 Add to MetaCart
(Show Context)
Instruction sequence based nonuniform complexity classes Bergstra, J.A.; Middelburg, C.A. General rights It is not permitted to download or to forward/distribute the text or part of it without the consent of the author(s) and/or copyright holder(s), other than for strictly personal, individual use, unless the work is under an open content license (like Creative Commons). Disclaimer/Complaints regulations If you believe that digital publication of certain material infringes any of your rights or (privacy) interests, please let the Library know, stating your reasons. In case of a legitimate complaint, the Library will make the material inaccessible and/or remove it from the website. Please Ask the Library: https://uba.uva.nl/en/contact, or a letter to: Library of the University of Amsterdam, Secretariat, Singel 425, 1012 WP Amsterdam, The Netherlands. You will be contacted as soon as possible. Abstract We present an approach to nonuniform complexity in which singlepass instruction sequences play a key part, and answer various questions that arise from this approach. We introduce several kinds of nonuniform complexity classes. One kind includes a counterpart of the wellknown nonuniform complexity class P/poly and another kind includes a counterpart of the wellknown nonuniform complexity class NP/poly. Moreover, we introduce a general notion of completeness for the nonuniform complexity classes of the latter kind. We also formulate a counterpart of the wellknown complexity theoretic conjecture that NP ⊆ P/poly. We think that the presented approach opens up an additional way of investigating issues concerning nonuniform complexity.
Flowchart Programs, Regular Expressions, and Decidability of Polynomial GrowthRate
, 2014
"... ..."
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
(Show Context)
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