4,777 research outputs found
Outcome Logic: A Unifying Foundation for Correctness and Incorrectness Reasoning
Program logics for bug-finding (such as the recently introduced Incorrectness
Logic) have framed correctness and incorrectness as dual concepts requiring
different logical foundations. In this paper, we argue that a single unified
theory can be used for both correctness and incorrectness reasoning. We present
Outcome Logic (OL), a novel generalization of Hoare Logic that is both monadic
(to capture computational effects) and monoidal (to reason about outcomes and
reachability). OL expresses true positive bugs, while retaining correctness
reasoning abilities as well. To formalize the applicability of OL to both
correctness and incorrectness, we prove that any false OL specification can be
disproven in OL itself. We also use our framework to reason about new types of
incorrectness in nondeterministic and probabilistic programs. Given these
advances, we advocate for OL as a new foundational theory of correctness and
incorrectness
Incorrectness Logic for Graph Programs
Program logics typically reason about an over-approximation of program
behaviour to prove the absence of bugs. Recently, program logics have been
proposed that instead prove the presence of bugs by means of under-approximate
reasoning, which has the promise of better scalability. In this paper, we
present an under-approximate program logic for a nondeterministic graph
programming language, and show how it can be used to reason deductively about
program incorrectness, whether defined by the presence of forbidden graph
structure or by finitely failing executions. We prove this incorrectness logic
to be sound and complete, and speculate on some possible future applications of
it.Comment: Accepted by the 14th International Conference on Graph Transformation
(ICGT 2021
Local reasoning about the presence of bugs: Incorrectness Separation Logic
There has been a large body of work on local reasoning for proving the absence of bugs, but none for proving their presence. We present a new formal framework for local reasoning about the presence of bugs, building on two complementary foundations: 1) separation logic and 2) incorrectness logic. We explore the theory of this new incorrectness separation logic (ISL), and use it to derive a begin-anywhere, intra-procedural symbolic execution analysis that has no false positives by construction. In so doing, we take a step towards transferring modular, scalable techniques from the world of program verification to bug catching
Логика для суждений об ошибках в циклах над последовательностями данных (IFIL)
Classic deductive verification is not focused on reasoning about program incorrectness. Reasoning about program incorrectness using formal methods is an important problem nowadays. Special logics such as Incorrectness Logic, Adversarial Logic, Local Completeness Logic, Exact Separation Logic and Outcome Logic have recently been proposed to address it. However, these logics have two disadvantages. One is that they are based on under-approximation approaches, while classic deductive verification is based on the over-approximation approach. One the other hand, the use of the classic approach requires defining loop invariants in a general case. The second disadvantage is that the use of generalized inference rules from these logics results in having to prove too complex formulas in simple cases. Our contribution is a new logic for solving these problems in the case of loops over data sequences. These loops are referred to as finite iterations. We call the proposed logic the Incorrectness Finite Iteration Logic (IFIL). We avoid defining invariants of finite iterations using a symbolic replacement of these loops with recursive functions. Our logic is based on special inference rules for finite iterations. These rules allow generating formulas with recursive functions corresponding to finite iterations. The validity of these formulas may indicate the presence of bugs in the finite iterations. This logic has been implemented in a new version of the C-lightVer system for deductive verification of C programs.Классическая дедуктивная верификация не ориентирована на доказательство некорректности программ. Доказательство некорректности программ с помощью формальных методов является актуальной задачей в настоящее время. Специальные логики, такие как Incorrectness Logic, Adversarial Logic, Local Completeness Logic, Exact Separation Logic и Outcome Logic, были недавно предложены для решения данной задачи. Но у данных логик имеется два недостатка. Во-первых, в данных логиках используются подходы, основанные на нижней аппроксимации, тогда как в классической дедуктивной верификации используется подход, основанный на верхней аппроксимации. С другой стороны, использование классического подхода требует в общем случае задания инвариантов циклов. Во-вторых, использование правил вывода для программных конструкций в их самом общем виде приводит к необходимости доказательства сложных формул в простых ситуациях. Нашим результатом, представленным в данной статье, является новая логика для решения данных проблем в случае циклов над последовательностями данных. Такая циклы мы называем финитными итерациями. Предложенную логику мы называем логикой для суждений о некорректности финитных итераций (IFIL). Мы избегаем задания инвариантов финитных итераций с помощью символической замены в условиях корректности переменных таких циклов применениями рекурсивных функций. Наша логика основана на специальных правилах вывода для финитных итераций. Эти правила позволяют выводить формулы с применениями рекурсивных функций, соответствующих финитным итерациям. Истинность этих формул может означать наличие ошибок в финитных итерациях. Данная логика была реализована в новой версии программной системы C-lightVer для дедуктивной верификации программ на языке C
Quantitative Strongest Post: A Calculus for Reasoning about the Flow of Quantitative Information
We present a novel strongest-postcondition-style calculus for quantitative
reasoning about non-deterministic programs with loops. Whereas existing
quantitative weakest pre allows reasoning about the value of a quantity after a
program terminates on a given initial state, quantitative strongest post allows
reasoning about the value that a quantity had before the program was executed
and reached a given final state. We show how strongest post enables reasoning
about the flow of quantitative information through programs. Similarly to
weakest liberal preconditions, we also develop a quantitative strongest liberal
post. As a byproduct, we obtain the entirely unexplored notion of strongest
liberal postconditions and show how these foreshadow a potential new program
logic - partial incorrectness logic - which would be a more liberal version of
O'Hearn's recent incorrectness logic
Epistemic Teleology: Synchronic and Diachronic
According to a widely held view of the matter, whenever we assess beliefs as ‘rational’ or ‘justified’, we are making normative judgements about those beliefs. In this discussion, I shall simply assume, for the sake of argument, that this view is correct. My goal here is to explore a particular approach to understanding the basic principles that explain which of these normative judgements are true. Specifically, this approach is based on the assumption that all such normative principles are grounded in facts about values, and the normative principles that apply to beliefs in particular are grounded in facts about alethic value––a kind of value that is exemplified by believing what is true and not believing what is false. In this chapter, I shall explain what I regard as the best way of interpreting this approach. In doing so, I shall also show how this interpretation can solve some problems that have recently been raised for approaches of this kind by Selim Berker, Jennifer Carr, Michael Caie, and Hilary Greaves
Verification of Imperative Programs by Constraint Logic Program Transformation
We present a method for verifying partial correctness properties of
imperative programs that manipulate integers and arrays by using techniques
based on the transformation of constraint logic programs (CLP). We use CLP as a
metalanguage for representing imperative programs, their executions, and their
properties. First, we encode the correctness of an imperative program, say
prog, as the negation of a predicate 'incorrect' defined by a CLP program T. By
construction, 'incorrect' holds in the least model of T if and only if the
execution of prog from an initial configuration eventually halts in an error
configuration. Then, we apply to program T a sequence of transformations that
preserve its least model semantics. These transformations are based on
well-known transformation rules, such as unfolding and folding, guided by
suitable transformation strategies, such as specialization and generalization.
The objective of the transformations is to derive a new CLP program TransfT
where the predicate 'incorrect' is defined either by (i) the fact 'incorrect.'
(and in this case prog is not correct), or by (ii) the empty set of clauses
(and in this case prog is correct). In the case where we derive a CLP program
such that neither (i) nor (ii) holds, we iterate the transformation. Since the
problem is undecidable, this process may not terminate. We show through
examples that our method can be applied in a rather systematic way, and is
amenable to automation by transferring to the field of program verification
many techniques developed in the field of program transformation.Comment: In Proceedings Festschrift for Dave Schmidt, arXiv:1309.455
Using global analysis, partial specifications, and an extensible assertion language for program validation and debugging
We discuss a framework for the application of abstract interpretation as an aid during program development, rather than in the more traditional application of program optimization. Program validation and detection of errors is first performed statically by comparing (partial) specifications written in terms of assertions against information obtained from (global) static analysis of the program. The results of this process are expressed in the user assertion language. Assertions (or parts of assertions) which cannot be checked statically are translated into run-time tests. The framework allows the use of assertions to be optional. It also allows using very general properties in assertions, beyond the predefined set understandable by the static analyzer and including properties defined by user programs. We also report briefly on an implementation of the framework. The resulting tool generates and checks assertions for Prolog, CLP(R), and CHIP/CLP(fd) programs, and integrates compile-time and run-time checking in a uniform way. The tool allows using properties such as types, modes, non-failure, determinacy,
and computational cost, and can treat modules separately, performing incremental analysis
On algebra of program correctness and incorrectness
Variants of Kleene algebra have been used to provide foundations of reasoning about programs, for instance by representing HoareLogic (HL) in algebra. That work has generally emphasised program correctness, i.e., proving the absence of bugs. Recently, Incorrectness Logic (IL) has been advanced as a formalism for the dual problem: proving thepresence of bugs. IL is intended to underpin the use of logic in programtesting and static bug finding. Here, we use a Kleene algebra with diamond operators and countable joins of tests, which embeds IL, and which also is complete for reasoning about the image of the embedding. Next to embedding IL, the algebra is able to embed HL, and allows making connections between IL and HL specifications. In this sense, it unifies correctness and incorrectness reasoning in one formalis
- …