The pitfalls of verifying floating-point computations

@article{Monniaux2008ThePO,
  title={The pitfalls of verifying floating-point computations},
  author={David Monniaux},
  journal={ArXiv},
  year={2008},
  volume={abs/cs/0701192}
}
  • D. Monniaux
  • Published 30 January 2007
  • Computer Science
  • ArXiv
Current critical systems often use a lot of floating-point computations, and thus the testing or static analysis of programs containing floating-point operators has become a priority. However, correctly defining the semantics of common implementations of floating-point is tricky, because semantics may change according to many factors beyond source-code level, such as choices made by compilers. We here give concrete examples of problems that can appear and solutions for implementing in analysis… 
Hardware-independent Proofs of Numerical Programs
TLDR
An approach for proving behavioral properties of numerical programs by analyzing their compiled assembly code by taking into account architecture- or compiler-dependent features such as the possible use of extended precision registers.
Automating the Verification of Floating-Point Programs
TLDR
This work combines multiple techniques to separately prove different parts of the desired properties of deductive program verification, using abstract interpretation to compute numerical bounds of expressions, and using multiple automated provers, relying on different strategies for representing floating-point computations.
Practical Floating-Point Tests with Integer Code
TLDR
This work proposes a software floating-point emulation extension for symbolic execution of binary programs, and has five distinct open source soft floating- point code bases.
Optimal inverse projection of floating-point addition
TLDR
This work proposes floating-point theorems that provide optimal bounds for all the intervals and fast loop-free algorithms compute these optimal bounds using onlyfloating-point computations at the target precision.
Synthesizing accurate floating-point formulas
  • A. Ioualalen, M. Martel
  • Computer Science
    2013 IEEE 24th International Conference on Application-Specific Systems, Architectures and Processors
  • 2013
TLDR
This article focuses on the synthesis of accurate formulas mathematically equal to the original formulas occurring in source codes, and addresses the problem of selecting an accurate formula among all the expressions of an APEG.
An Automatable Formal Semantics for IEEE-754 Floating-Point Arithmetic
TLDR
A formalization of the IEEE-754 standard for floating-point arithmetic as a theory in many-sorted first-order logic is presented, providing a standardized syntax and unambiguous semantics, allowing tool interoperability and sharing of benchmarks, and providing a basis for automated, formal analysis of programs that process floating- point data.
RAIVE: runtime assessment of floating-point instability by vectorization
TLDR
This work proposes RAIVE, a technique that identifies output variations of a floating point execution in the presence of instability, and shows that RAIVE can precisely capture output variations.
A Practical Approach to Verification of Floating-Point C/C++ Programs with math.h/cmath Functions
Verification of C/C++ programs has seen considerable progress in several areas, but not for programs that use these languages’ mathematical libraries. The reason is that all libraries in widespread
Finding Root Causes of Floating Point Error with Herbgrind
TLDR
Herbgrind is presented, a tool to help developers identify and address root causes in numerical code written in low-level C/C++ and Fortran, and dynamically tracks dependencies between operations and program outputs to avoid false positives.
...
1
2
3
4
5
...

References

SHOWING 1-10 OF 115 REFERENCES
Static Analyses of the Precision of Floating-Point Operations
TLDR
This article gives a (sketch of a) semantics of its basic operations then abstract them (in the sense of abstract interpretation) to extract information about the possible loss of precision in floating-point operations.
Formal Verification of Floating-Point Programs
  • S. Boldo, J. Filliâtre
  • Computer Science, Engineering
    18th IEEE Symposium on Computer Arithmetic (ARITH '07)
  • 2007
TLDR
An existing tool for the verification of C programs, Caduceus, is extended with new annotations specific to floating-point arithmetic, which is already implemented and has been successfully applied to several short floatingpoint programs, which are presented in this paper.
On the need for predictable floating-point arithmetic in the programming languages Fortran 90 and C/C++
TLDR
In this report, a number of Fortran 90 and C/C++ compilers for workstations as well as personal computers will be screened with respect to their IEEE conformance and it will be shown that most of these compilers do not conform to the IEEE standard.
Relational Abstract Domains for the Detection of Floating-Point Run-Time Errors
TLDR
It is shown how to extend already existing numerical abstract domains, such as the octagon abstract domain, to efficiently abstract transfer functions based on interval linear forms to statically detect potential floating-point run-time exceptions such as overflows or invalid operations.
Design and Implementation of a Special-Purpose Static Program Analyzer for Safety-Critical Real-Time Embedded Software
We report on a successful preliminary experience in the design and implementation of a special-purpose Abstract Interpretation based static program analyzer for the verification of safety critical
Analyzing Memory Accesses in x86 Executables
TLDR
The aim of the work is to recover intermediate representations that are similar to those that can be created for a program written in a high-level language by static-analysis algorithms for analyzing x86 executables.
Propagation of Roundoff Errors in Finite Precision Computations: A Semantics Approach
TLDR
A concrete semantics for floating-point operations which describes the propagation of roundoff errors throughout a computation and considers also coarser semantics computing the contribution, to the final error, of the errors due to some intermediate computations.
Semantics of roundoff error propagation in finite precision calculations
  • M. Martel
  • Computer Science
    High. Order Symb. Comput.
  • 2006
TLDR
A concrete semantics for floating-point operations is introduced which describes the propagation of roundoff errors throughout a calculation and it is shown that the less precise ones are abstractions of the more precise ones.
Static Analysis of the Numerical Stability of Loops
We introduce a relational static analysis to determine the stability of the numerical errors arising inside a loop in which floating-point computations are carried out. This analysis is based on a
A static analyzer for large safety-critical software
We show that abstract interpretation-based static program analysis can be made efficient and precise enough to formally verify a class of properties for a family of large programs with few or no
...
1
2
3
4
5
...