A copy of this work was available on the public web and has been preserved in the Wayback Machine. The capture dates from 2020; you can also visit the original URL.
The file type is `application/pdf`

.

## Filters

##
###
Spatial Interpolants
[article]

2015
*
arXiv
*
pre-print

We propose Splinter, a new technique for proving properties of heap-manipulating programs that marries (1) a new separation logic-based analysis for heap reasoning with (2) an interpolation-based technique for refining heap-shape invariants with data invariants. Splinter is property directed, precise, and produces counterexample traces when a property does not hold. Using the novel notion of spatial interpolants modulo theories, Splinter can infer complex invariants over general recursive

arXiv:1501.04100v1
fatcat:zkbago6jmnahbixu5bqcprr3c4
## more »

... ates, e.g., of the form all elements in a linked list are even or a binary tree is sorted. Furthermore, we treat interpolation as a black box, which gives us the freedom to encode data manipulation in any suitable theory for a given program (e.g., bit vectors, arrays, or linear arithmetic), so that our technique immediately benefits from any future advances in SMT solving and interpolation.##
###
Proving Liveness of Parameterized Programs
[article]

2016
*
arXiv
*
pre-print

Correctness of multi-threaded programs typically requires that they satisfy liveness properties. For example, a program may require that no thread is starved of a shared resource, or that all threads eventually agree on a single value. This paper presents a method for proving that such liveness properties hold. Two particular challenges addressed in this work are that (1) the correctness argument may rely on global behaviour of the system (e.g., the correctness argument may require that all

arXiv:1605.02350v1
fatcat:m5xvzbep5vd6zdvhbt6l27pxh4
## more »

... ads collectively progress towards "the good thing" rather than one thread progressing while the others do not interfere), and (2) such programs are often designed to be executed by any number of threads, and the desired liveness properties must hold regardless of the number of threads that are active in the program.##
###
Compositional Invariant Generation via Linear Recurrence Analysis
[article]

2015
*
arXiv
*
pre-print

This paper presents a new method for automatically generating numerical invariants for imperative programs. Given a program, our procedure computes a binary input/output relation on program states which over-approximates the behaviour of the program. It is compositional in the sense that it operates by decomposing the program into parts, computing an abstract meaning of each part, and then composing the meanings. Our method for approximating loop behaviour is based on first approximating the

arXiv:1502.00138v1
fatcat:vlyjzek2pzflrhruwg6jytdr2q
## more »

... ning of the loop body, extracting recurrence relations from that approximation, and then using the closed forms to approximate the loop. Our experiments demonstrate that on verification tasks, our method is competitive with leading invariant generation and verification tools.##
###
An Algebraic Framework for Compositional Program Analysis
[article]

2013
*
arXiv
*
pre-print

The purpose of a program analysis is to compute an abstract meaning for a program which approximates its dynamic behaviour. A compositional program analysis accomplishes this task with a divide-and-conquer strategy: the meaning of a program is computed by dividing it into sub-programs, computing their meaning, and then combining the results. Compositional program analyses are desirable because they can yield scalable (and easily parallelizable) program analyses. This paper presents algebraic

arXiv:1310.3481v1
fatcat:42sj26xl5jbe5iasdgczyi4vpe
## more »

... mework for designing, implementing, and proving the correctness of compositional program analyses. A program analysis in our framework defined by an algebraic structure equipped with sequencing, choice, and iteration operations. From the analysis design perspective, a particularly interesting consequence of this is that the meaning of a loop is computed by applying the iteration operator to the loop body. This style of compositional loop analysis can yield interesting ways of computing loop invariants that cannot be defined iteratively. We identify a class of algorithms, the so-called path-expression algorithms [Tarjan1981,Scholz2007], which can be used to efficiently implement analyses in our framework. Lastly, we develop a theory for proving the correctness of an analysis by establishing an approximation relationship between an algebra defining a concrete semantics and an algebra defining an analysis.##
###
Termination Analysis Without the Tears
[article]

2021
*
arXiv
*
pre-print

Farzan and

arXiv:2101.09783v1
fatcat:hipzhvwlxbcgdfnjwmdrt6cof4
*Kincaid*[26] give an algorithm for computing conv( ). ...##
###
Spatial Interpolants
[chapter]

2015
*
Lecture Notes in Computer Science
*

We propose SplInter, a new technique for proving properties of heap-manipulating programs that marries (1) a new separation logic-based analysis for heap reasoning with (2) an interpolation-based technique for refining heap-shape invariants with data invariants. SplInter is property directed, precise, and produces counterexample traces when a property does not hold. Using the novel notion of spatial interpolants modulo theories, SplInter can infer complex invariants over general recursive

doi:10.1007/978-3-662-46669-8_26
fatcat:igaxfz3slvbdtbv3odp57drxke
## more »

... ates, e.g., of the form all elements in a linked list are even or a binary tree is sorted. Furthermore, we treat interpolation as a black box, which gives us the freedom to encode data manipulation in any suitable theory for a given program (e.g., bit vectors, arrays, or linear arithmetic), so that our technique immediately benefits from any future advances in SMT solving and interpolation.##
###
MEK/ERK addiction in CNL/aCML

2017
*
OncoTarget
*

MEK/ERK addiction in CNL/aCML Meenu Kesarwani,

doi:10.18632/oncotarget.22283
pmid:29245892
pmcid:PMC5725083
fatcat:3r66qwdzjbd5jiu4oaw35p7cq4
*Zachary**Kincaid*and Mohammad Azam Recent discovery of mutations in CSF3R and activation of JAK-STAT signaling in chronic neutrophilic leukemia (CNL) and atypical ...##
###
Duplication in DNA Sequences
[chapter]

2009
*
Natural Computing Series
*

Duplication and repeat-deletion are the basic models of errors occurring during DNA replication from the viewpoint of formal languages. During DNA replication, subsequences of a strand of DNA may be copied several times (duplication) or skipped (repeat-deletion). Iterated duplication and repeat-deletion have been well-studied, but little is known about single-step duplication and repeat-deletion. In this paper, we investigate properties of these operations, such as closure properties of

doi:10.1007/978-3-540-88869-7_4
fatcat:2uzs3yvhgjegbj6lqodpryvu34
## more »

... families in the Chomsky hierarchy, language equations involving these operations. We also make progress towards a characterization of regular languages that are generated by duplicating a regular language.##
###
Inductive data flow graphs

2013
*
SIGPLAN notices
*

The correctness of a sequential program can be shown by the annotation of its control flow graph with inductive assertions. We propose inductive data flow graphs, data flow graphs with incorporated inductive assertions, as the basis of an approach to verifying concurrent programs. An inductive data flow graph accounts for a set of dependencies between program actions in interleaved thread executions, and therefore stands as a representation for the set of concurrent program traces which give

doi:10.1145/2480359.2429086
fatcat:3b4u5c4mwrgvlgh4qda6k67eh4
## more »

... e to these dependencies. The approach first constructs an inductive data flow graph and then checks whether all program traces are represented. The size of the inductive data flow graph is polynomial in the number of data dependencies (in a sense that can be made formal); it does not grow exponentially in the number of threads unless the data dependencies do. The approach shifts the burden of the exponential explosion towards the check whether all program traces are represented, i.e., to a combinatorial problem (over finite graphs).##
###
Algebraic Program Analysis
[chapter]

2021
*
Lecture Notes in Computer Science
*

AbstractThis paper is a tutorial on algebraic program analysis. It explains the foundations of algebraic program analysis, its strengths and limitations, and gives examples of algebraic program analyses for numerical invariant generation and termination analysis.

doi:10.1007/978-3-030-81685-8_3
fatcat:375brjonbbgfdfwpp72juwnljq
##
###
Recursive Program Synthesis
[chapter]

2013
*
Lecture Notes in Computer Science
*

Input-output examples are a simple and accessible way of describing program behaviour. Program synthesis from input-output examples has the potential of extending the range of computational tasks achievable by end-users who have no programming knowledge, but can articulate their desired computations by describing input-output behaviour. In this paper, we present Escher, a generic and efficient algorithm that interacts with the user via input-output examples, and synthesizes recursive programs

doi:10.1007/978-3-642-39799-8_67
fatcat:xz2risoou5gvlhatakd2lk73zu
## more »

... plementing intended behaviour. Escher is parameterized by the components (instructions) that can be used in the program, thus providing a generic synthesis algorithm that can be instantiated to suit different domains. To search through the space of programs, Escher adopts a novel search strategy that utilizes special data structures for inferring conditionals and synthesizing recursive procedures. Our experimental evaluation of Escher demonstrates its ability to efficiently synthesize a wide range of programs, manipulating integers, lists, and trees. Moreover, we show that Escher outperforms a state-ofthe-art SAT-based synthesis tool from the literature.##
###
A Symbolic Decision Procedure for Symbolic Alternating Finite Automata
[article]

2016
*
arXiv
*
pre-print

We introduce Symbolic Alternating Finite Automata (s-AFA) as an expressive, succinct, and decidable model for describing sets of finite sequences over arbitrary alphabets. Boolean operations over s-AFAs have linear complexity, which is in sharp contrast with the quadratic cost of intersection and union for non-alternating symbolic automata. Due to this succinctness, emptiness and equivalence checking are PSpace-hard. We introduce an algorithm for checking the equivalence of two s-AFAs based on

arXiv:1610.01722v1
fatcat:3b3czuwwyncihguk54r2f2zouy
## more »

... isimulation up to congruence. This algorithm allows us to exploit the power of SAT and SMT solvers to efficiently search the state space of the s-AFAs. We evaluate our decision procedure on two verification and security applications: 1) checking satisfiability of linear temporal logic formulas over finite traces, and 2) checking equivalence of Boolean combinations of regular expressions. Our experiments show that our technique often outperforms existing techniques and it can be beneficial in both such applications.##
###
Proof Spaces for Unbounded Parallelism

2015
*
SIGPLAN notices
*

In this paper, we present a new approach to automatically verify multi-threaded programs which are executed by an unbounded number of threads running in parallel. The starting point for our work is the problem of how we can leverage existing automated verification technology for sequential programs (abstract interpretation, Craig interpolation, constraint solving, etc.) for multi-threaded programs. Suppose that we are given a correctness proof for a trace of a program (or for some other program

doi:10.1145/2775051.2677012
fatcat:b4heebu7ybdo3ndjfkvvfrji3e
## more »

... fragment). We observe that the proof can always be decomposed into a finite set of Hoare triples, and we ask what can be proved from the finite set of Hoare triples using only simple combinatorial inference rules (without access to a theorem prover and without the possibility to infer genuinely new Hoare triples)? We introduce a proof system where one proves the correctness of a multi-threaded program by showing that for each trace of the program, there exists a correctness proof in the space of proofs that are derivable from a finite set of axioms using simple combinatorial inference rules. This proof system is complete with respect to the classical proof method of establishing an inductive invariant (which uses thread quantification and control predicates). Moreover, it is possible to algorithmically check whether a given set of axioms is sufficient to prove the correctness of a multi-threaded program, using ideas from well-structured transition systems.##
###
Compositional recurrence analysis revisited

2017
*
SIGPLAN notices
*

##
###
Compositional recurrence analysis

2015
*
2015 Formal Methods in Computer-Aided Design (FMCAD)
*

« Previous

*Showing results 1 — 15 out of 170 results*