🤖 AI Summary
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.
📝 Abstract
This dissertation explores the design and implementation of programming languages that represent rounding error analysis through typing. The first part of this dissertation demonstrates that it is possible to design languages for forward error analysis, as illustrated with NumFuzz, a functional programming language whose type system expresses quantitative bounds on rounding error. This type system combines a sensitivity analysis, enforced through a linear typing discipline, with a novel graded monad to track the accumulation of rounding errors. We establish the soundness of the type system by relating the denotational semantics of the language to both an exact and floating-point operational semantics. To demonstrate the practical utility of NumFuzz as a tool for automated error analysis, we have developed a prototype implementation capable of automatically inferring error bounds. Our implementation produces bounds competitive with existing tools, while often achieving significantly faster analysis times. The second part of this dissertation explores a type-based approach to backward error analysis with Bean, a first-order programming language with a linear type system that can express quantitative bounds on backward error. Bean's type system combines a graded coeffect system with strict linearity to soundly track the flow of backward error through programs. To illustrate Bean's potential as a practical tool for automated backward error analysis, we implement a variety of standard algorithms from numerical linear algebra in Bean, establishing fine-grained backward error bounds via typing in a compositional style. We also develop a prototype implementation of Bean that infers backward error bounds automatically. Our evaluation shows that these inferred bounds match worst-case theoretical relative backward error bounds from the literature.