3,435 research outputs found
Inferring Lower Bounds for Runtime Complexity
We present the first approach to deduce lower bounds for innermost runtime complexity of term rewrite systems (TRSs) automatically. Inferring lower runtime bounds is useful to detect bugs and to complement existing techniques that compute upper complexity
bounds. The key idea of our approach is to generate suitable families of rewrite sequences of a TRS and to find a relation between the length of such a rewrite sequence and the size of the first term in the sequence. We implemented our approach in
the tool AProVE and evaluated it by extensive experiments
Transfer Function Synthesis without Quantifier Elimination
Traditionally, transfer functions have been designed manually for each
operation in a program, instruction by instruction. In such a setting, a
transfer function describes the semantics of a single instruction, detailing
how a given abstract input state is mapped to an abstract output state. The net
effect of a sequence of instructions, a basic block, can then be calculated by
composing the transfer functions of the constituent instructions. However,
precision can be improved by applying a single transfer function that captures
the semantics of the block as a whole. Since blocks are program-dependent, this
approach necessitates automation. There has thus been growing interest in
computing transfer functions automatically, most notably using techniques based
on quantifier elimination. Although conceptually elegant, quantifier
elimination inevitably induces a computational bottleneck, which limits the
applicability of these methods to small blocks. This paper contributes a method
for calculating transfer functions that finesses quantifier elimination
altogether, and can thus be seen as a response to this problem. The
practicality of the method is demonstrated by generating transfer functions for
input and output states that are described by linear template constraints,
which include intervals and octagons.Comment: 37 pages, extended version of ESOP 2011 pape
Inferring Lower Runtime Bounds for Integer Programs
We present a technique to infer lower bounds on the worst-case runtime complexity of integer programs, where in contrast to earlier work, our approach is not restricted to tail-recursion. Our technique constructs symbolic representations of program executions using a framework for iterative, under-approximating program simplification. The core of this simplification is a method for (under-approximating) program acceleration based on recurrence solving and a variation of ranking functions. Afterwards, we deduce asymptotic lower bounds from the resulting simplified programs using a special-purpose calculus and an SMT encoding. We implemented our technique in our tool LoAT and show that it infers non-trivial lower bounds for a large class of examples
High-dimensional learning of linear causal networks via inverse covariance estimation
We establish a new framework for statistical estimation of directed acyclic
graphs (DAGs) when data are generated from a linear, possibly non-Gaussian
structural equation model. Our framework consists of two parts: (1) inferring
the moralized graph from the support of the inverse covariance matrix; and (2)
selecting the best-scoring graph amongst DAGs that are consistent with the
moralized graph. We show that when the error variances are known or estimated
to close enough precision, the true DAG is the unique minimizer of the score
computed using the reweighted squared l_2-loss. Our population-level results
have implications for the identifiability of linear SEMs when the error
covariances are specified up to a constant multiple. On the statistical side,
we establish rigorous conditions for high-dimensional consistency of our
two-part algorithm, defined in terms of a "gap" between the true DAG and the
next best candidate. Finally, we demonstrate that dynamic programming may be
used to select the optimal DAG in linear time when the treewidth of the
moralized graph is bounded.Comment: 41 pages, 7 figure
- …