finite-precision error analysis

This work addresses the problem of deriving provably tight floating-point rounding error bounds for numerical programs featuring conditional branches, no loops, and mixed-precision arithmetic. Methodologically, it unifies the modeling of conditional control flow and precision heterogeneity via two novel quantitative metrics—“instability jumps” and “window width”—and integrates interval arithmetic, abstract interpretation, and precision-aware semantic modeling, augmented with abstraction-guided global optimization. Its key contribution is the first formal framework enabling joint, compositional analysis of conditional branching and mixed precision, achieving both high bound tightness and practical analysis efficiency. Experimental evaluation on standard benchmarks demonstrates significantly tighter error bounds compared to prior approaches. Furthermore, the framework successfully guides precision configuration—e.g., step size and search direction—in the conjugate gradient method, empirically validating its utility in supporting design-time trade-offs among accuracy, error bounds, and computational efficiency.

This paper addresses the challenge of automated quantitative roundoff error analysis in numerical computing. We propose two type-driven languages: NumFuzz for forward error analysis and Bean for backward error analysis. Our key innovation is the deep integration of error modeling into the type system—NumFuzz combines sensitivity analysis with graded monads to derive tight forward error bounds at compile time; Bean employs graded coeffects and strict linear types to enable compositional backward error reasoning. Both languages are grounded in denotational semantics, tightly coupling floating-point and exact real semantics to ensure correctness, and support fully automatic type inference. Evaluation shows that NumFuzz infers forward error bounds significantly faster than state-of-the-art tools while maintaining comparable precision. For numerical linear algebra algorithms, Bean automatically derives fine-grained backward error bounds that match worst-case theoretical bounds reported in the literature.

This work addresses the challenge of statically quantifying rounding errors in floating-point computations. We introduce Λnum, a functional language that—uniquely—integrates sensitivity analysis with graded monads within a linear type system, enabling fully automatic, sound static inference of upper bounds on rounding errors in numerical programs. Λnum natively models IEEE 754 rounding semantics and supports extensions to nondeterministic and stochastic rounding. By rigorously connecting denotational and operational semantics, we establish, for the first time at the type level, soundness guarantees for inferred error bounds. Our prototype implementation demonstrates effectiveness across multiple classical numerical algorithms: it achieves error-bound precision comparable to state-of-the-art tools while significantly accelerating inference speed.

Floating-point errors pose significant risks in safety-critical systems, yet only a subset of inputs triggers substantial inaccuracies—necessitating efficient and precise detection methods. Existing approaches face critical limitations: high-precision reference methods suffer from implementation complexity and prohibitive computational overhead; ATOMU incurs false positives; while FPCC guarantees zero false positives, it exhibits poor efficiency. This paper proposes PI-detector—the first method to model input sensitivity based on the condition number of atomic floating-point operations. By injecting minimal perturbations into fundamental operations (e.g., addition and subtraction) and performing rigorous error propagation analysis, PI-detector automatically quantifies input sensitivity without resorting to expensive high-precision arithmetic. It achieves accuracy comparable to high-precision references while significantly outperforming FPCC in execution speed and eliminating false positives entirely. Experimental evaluation covers the ATOMU and HSED benchmarks, as well as linear system solvers.

This work addresses the prevalent overuse of double-precision floating-point numbers in numerical programs by proposing an automated mixed-precision tuning methodology. The approach supports user-defined, non-standard low-precision floating-point formats with customizable exponent and mantissa bit-widths, and integrates numerical validation with systematic search within a unified framework to automatically generate program variants that meet prescribed accuracy constraints. Leveraging the PROMISE tool and containerized parallel benchmarking, the method demonstrates that numerous variables across a range of numerical applications and the Rodinia benchmark suite can be safely downgraded in precision. This reduction yields significant improvements in performance while simultaneously decreasing memory consumption and energy usage, all without compromising numerical accuracy.

This work addresses the lack of formal verification foundations for the IEEE P3109 low-precision floating-point standard, whose flexible format and novel features—such as stochastic rounding and saturating arithmetic—pose unique challenges. We present the first complete, parameterized formal model of P3109 in the Lean theorem prover, enabling machine-checkable analysis of its semantics, operations, and key algorithms. Our contributions include the first mechanically verified specification of P3109, a proof that FastTwoSum precisely captures overflow error under saturating arithmetic, and the discovery that ExtractScalar fails at 1-bit precision. The accompanying open-source formal library provides a reusable foundation for the reliable verification of low-precision numerical software.

Floating-point round-off errors are ubiquitous in numerically intensive programs arising in fields such as scientific computing and optimization. As floating-point errors potentially lead to unexpected and catastrophic program failures, one must derive guaranteed round-off thresholds to ensure the correctness of these programs. However, deterministic round-off thresholds tend to be too conservative to be usable in practice, since they often involve large round-off errors that occur with small probability. Probabilistic thresholds relax deterministic ones by specifying that the probability of the round-off error exceeding a threshold is below a given confidence. In this work, we propose a novel approach to probabilistic round-off analysis, by applying concentration inequalities over the Taylor expansion from FPTaylor (TOPLAS 2018). A major obstacle in applying concentration inequalities is that the Taylor expansion involves absolute value operators that make the calculation of the expected values of the first order partial differential terms difficult. Our first step to overcome this obstacle is a sound over-approximation that removes the absolute value operators in polynomial expressions. Then, we show how to handle fractional expressions by a transformation into polynomial case. Finally, we show how to improve our approach with range partitioning. Our approach is scalable since the key computational part is the calculation of expected values of polynomial expressions with independent variables, for which the linear and independence properties of expectation boost the computation. Experimental results show that our approach is orders of magnitude more time efficient, while producing thresholds with comparable precision against the state of the art.

Existing approaches lack the capability to perform automated backward error analysis for numerical programs, making it difficult to verify their backward stability. This work proposes a formal framework that generalizes the definition of backward stability, introduces the category Shel to model stable numerical computations, and develops the tool eggshel to automatically synthesize error bounds. The framework incorporates a novel, composable, and flexible notion of stability, integrating category theory, formal verification, and symbolic reasoning to automatically search for stability proofs within subcategories of Shel. Notably, eggshel is the first tool capable of automating the analysis of programs with variable reuse, successfully generating backward error bounds for several numerical programs previously beyond the reach of existing methods, while providing formal correctness guarantees.

This work addresses the widespread lack of correctly rounded results in high-performance vector math libraries, which undermines bit-level reproducibility across platforms. The authors propose a unified framework that integrates SIMD parallelism with correctly rounded algorithms to efficiently implement multiple single-precision, single-input mathematical functions on CPUs and, for the first time, extend this approach to GPUs. They also provide a prototype implementation for double-precision functions. This research lays the foundation for the first cross-platform vector math library supporting correct rounding, with a planned public release by mid-2026, significantly advancing reproducibility and precision guarantees in numerical computing.