11 research outputs found
Proof Theory at Work: Complexity Analysis of Term Rewrite Systems
This thesis is concerned with investigations into the "complexity of term
rewriting systems". Moreover the majority of the presented work deals with the
"automation" of such a complexity analysis. The aim of this introduction is to
present the main ideas in an easily accessible fashion to make the result
presented accessible to the general public. Necessarily some technical points
are stated in an over-simplified way.Comment: Cumulative Habilitation Thesis, submitted to the University of
Innsbruc
A Combination Framework for Complexity
In this paper we present a combination framework for polynomial complexity
analysis of term rewrite systems. The framework covers both derivational and
runtime complexity analysis. We present generalisations of powerful complexity
techniques, notably a generalisation of complexity pairs and (weak) dependency
pairs. Finally, we also present a novel technique, called dependency graph
decomposition, that in the dependency pair setting greatly increases
modularity. We employ the framework in the automated complexity tool TCT. TCT
implements a majority of the techniques found in the literature, witnessing
that our framework is general enough to capture a very brought setting
A Complexity Preserving Transformation from Jinja Bytecode to Rewrite Systems
We revisit known transformations from Jinja bytecode to rewrite systems from
the viewpoint of runtime complexity. Suitably generalising the constructions
proposed in the literature, we define an alternative representation of Jinja
bytecode (JBC) executions as "computation graphs" from which we obtain a novel
representation of JBC executions as "constrained rewrite systems". We prove
non-termination and complexity preservation of the transformation. We restrict
to well-formed JBC programs that only make use of non-recursive methods and
expect tree-shaped objects as input. Our approach allows for simplified
correctness proofs and provides a framework for the combination of the
computation graph method with standard techniques from static program analysis
like for example "reachability analysis".Comment: 36 page
Modular Complexity Analysis for Term Rewriting
All current investigations to analyze the derivational complexity of term
rewrite systems are based on a single termination method, possibly preceded by
transformations. However, the exclusive use of direct criteria is problematic
due to their restricted power. To overcome this limitation the article
introduces a modular framework which allows to infer (polynomial) upper bounds
on the complexity of term rewrite systems by combining different criteria.
Since the fundamental idea is based on relative rewriting, we study how matrix
interpretations and match-bounds can be used and extended to measure complexity
for relative rewriting, respectively. The modular framework is proved strictly
more powerful than the conventional setting. Furthermore, the results have been
implemented and experiments show significant gains in power.Comment: 33 pages; Special issue of RTA 201
The Derivational Complexity Induced by the Dependency Pair Method
We study the derivational complexity induced by the dependency pair method,
enhanced with standard refinements. We obtain upper bounds on the derivational
complexity induced by the dependency pair method in terms of the derivational
complexity of the base techniques employed. In particular we show that the
derivational complexity induced by the dependency pair method based on some
direct technique, possibly refined by argument filtering, the usable rules
criterion, or dependency graphs, is primitive recursive in the derivational
complexity induced by the direct method. This implies that the derivational
complexity induced by a standard application of the dependency pair method
based on traditional termination orders like KBO, LPO, and MPO is exactly the
same as if those orders were applied as the only termination technique
Analysing the Complexity of Functional Programs: Higher-Order Meets First-Order
International audienceWe show how the complexity of higher-order functional programs can be analysed automatically by applying program transformations to a defunctionalized versions of them, and feeding the result to existing tools for the complexity analysis of first-order term rewrite systems. This is done while carefully analysing complexity preservation and reflection of the employed transformations such that the complexity of the obtained term rewrite system reflects on the complexity of the initial program. Further, we describe suitable strategies for the application of the studied transformations and provide ample experimental data for assessing the viability of our method