Laura Titolo
Research Subjects
Laura Titolo has a total of 32 co-authors. Here are the top co-authors by number of shared publications:
- Mariano M. Moscato
Analytical Mechanics Associates Inc
8 shared publications - Cesar A. Muñoz
NASA Langley Research Center
7 shared publications - Alicia Villanueva
Universitat Politècnica de València
6 shared publications - Marco Comini
University of Udine
6 shared publications César A. Muñoz
NASA Langley Research Center
4 shared publicationsMarco A. Feliú
National Institute of Aerospace
4 shared publications
Latest Publications
- Open Access
- 2 October 2026
- Published by Association for Computing Machinery (ACM)
- p. 1
Numerical Abstract Domains for Trustworthy Code Transpilation (Keynote)
LLMs are making code modernization, translation, and rewriting easier and more scalable, enabling software to be transpiled across programming languages and compilers, and optimized for specific hardware platforms. For numerical software relying on finite-precision arithmetic, however, these transformations may introduce numerical deviations that are difficult to predict. Changing the programming language, compiler, execution model, or hardware platform can alter floating-point behavior through differences in precision, rounding, overflow, and the handling of exceptional values. These differences can accumulate into observable changes in program behavior, even when the transformed program produces results equivalent to those of the initial program under real-number semantics. Ensuring trustworthy code transpilation therefore requires reasoning about the finite-precision behavior of the transformed program, taking into account its execution environment and target hardware. This talk presents a retrospective on numerical abstract domains developed to soundly reason about floating-point semantics. It traces the evolution from interval abstractions to richer domains, such as zonotopes and floating-point polyhedra. It then examines how these abstractions have been used to build static analyses for verifying numerical properties of real-world software. This retrospective highlights the trade-offs between the precision, computational cost, and scalability of different abstract domains. The talk then explores how these static analyses can be incorporated into LLM-based code transpilation pipelines. These analyses can assess and guide LLM-based code transformations, allowing the transpilation process to detect changes in finite-precision behavior and determine whether the resulting deviations from ideal real-number semantics are acceptable for the target application. This approach can support a range of requirements, from guaranteeing that numerical error remains within a specified tolerance to enabling performance-driven transformations such as reduced-precision implementations, while providing evidence that the resulting code meets the required accuracy.
- 2 October 2026
- Published by Association for Computing Machinery (ACM)
- p. 1
Open AccessNumerical Abstract Domains for Trustworthy Code Transpilation (Keynote)
LLMs are making code modernization, translation, and rewriting easier and more scalable, enabling software to be transpiled across programming languages and compilers, and optimized for specific hardware platforms. For numerical software relying on finite-precision arithmetic, however, these transformations may introduce numerical deviations that are difficult to predict. Changing the programming language, compiler, execution model, or hardware platform can alter floating-point behavior through differences in precision, rounding, overflow, and the handling of exceptional values. These differences can accumulate into observable changes in program behavior, even when the transformed program produces results equivalent to those of the initial program under real-number semantics. Ensuring trustworthy code transpilation therefore requires reasoning about the finite-precision behavior of the transformed program, taking into account its execution environment and target hardware. This talk presents a retrospective on numerical abstract domains developed to soundly reason about floating-point semantics. It traces the evolution from interval abstractions to richer domains, such as zonotopes and floating-point polyhedra. It then examines how these abstractions have been used to build static analyses for verifying numerical properties of real-world software. This retrospective highlights the trade-offs between the precision, computational cost, and scalability of different abstract domains. The talk then explores how these static analyses can be incorporated into LLM-based code transpilation pipelines. These analyses can assess and guide LLM-based code transformations, allowing the transpilation process to detect changes in finite-precision behavior and determine whether the resulting deviations from ideal real-number semantics are acceptable for the target application. This approach can support a range of requirements, from guaranteeing that numerical error remains within a specified tolerance to enabling performance-driven transformations such as reduced-precision implementations, while providing evidence that the resulting code meets the required accuracy.
- Open Access
- 13 September 2024
- Published by Springer Nature
- p. 20-38
Rigorous Floating-Point Round-Off Error Analysis in PRECiSA 4.0
Small round-off errors in safety-critical systems can lead to catastrophic consequences. In this context, determining if the result computed by a floating-point program is accurate enough with respect to its ideal real-number counterpart is essential. This paper presents PRECiSA 4.0, a tool that rigorously estimates the accumulated round-off error of a floating-point program. PRECiSA 4.0 combines static analysis, optimization techniques, and theorem proving to provide a modular approach for computing a provably correct round-off error estimation. PRECiSA 4.0 adds several features to previous versions of the tool that enhance its applicability and performance. These features include support for data collections such as lists, records, and tuples; support for recursion schemas; an updated floating-point formalization that closely characterizes the IEEE-754 standard; an efficient and modular analysis of function calls that improves the performances for large programs; and a new user interface integrated into Visual Studio Code.
- 13 September 2024
- Published by Springer Nature
- p. 20-38
Open AccessRigorous Floating-Point Round-Off Error Analysis in PRECiSA 4.0
Small round-off errors in safety-critical systems can lead to catastrophic consequences. In this context, determining if the result computed by a floating-point program is accurate enough with respect to its ideal real-number counterpart is essential. This paper presents PRECiSA 4.0, a tool that rigorously estimates the accumulated round-off error of a floating-point program. PRECiSA 4.0 combines static analysis, optimization techniques, and theorem proving to provide a modular approach for computing a provably correct round-off error estimation. PRECiSA 4.0 adds several features to previous versions of the tool that enhance its applicability and performance. These features include support for data collections such as lists, records, and tuples; support for recursion schemas; an updated floating-point formalization that closely characterizes the IEEE-754 standard; an efficient and modular analysis of function calls that improves the performances for large programs; and a new user interface integrated into Visual Studio Code.
- Open Access
- 20 March 2024
- Published by Springer Nature
- p. C1
Correction to: Formal Methods for Industrial Critical Systems
- 20 March 2024
- Published by Springer Nature
- p. C1
Open AccessCorrection to: Formal Methods for Industrial Critical Systems
- 18 October 2023
- Published by Springer Nature in Innovations in Systems and Software Engineering
- Vol. 19 (4) , 337-338
Selected extended papers of NFM 2021
- 18 October 2023
- Published by Springer Nature in Innovations in Systems and Software Engineering
- Vol. 19 (4) , 337-338
Selected extended papers of NFM 2021
- 22 July 2023
- Published by Springer Nature
- p. 197-220
Floating-Point Round-off Error Analysis of Safety-Critical Avionics Software
- 22 July 2023
- Published by Springer Nature
- p. 197-220
Floating-Point Round-off Error Analysis of Safety-Critical Avionics Software
- Open Access
- 11 January 2022
- Published by Association for Computing Machinery (ACM)
- p. 68-81
A compositional proof framework for FRETish requirements
Structured natural languages provide a trade space between ambiguous natural languages that make up most written requirements, and mathematical formal specifications such as Linear Temporal Logic. FRETish is a structured natural language for the elicitation of system requirements developed at NASA. The related open-source tool Fret provides support for translating FRETish requirements into temporal logic formulas that can be input to several verification and analysis tools. In the context of safety-critical systems, it is crucial to ensure that a generated formula captures the semantics of the corresponding FRETish requirement precisely. This paper presents a rigorous formalization of the FRETish language including a new denotational semantics and a proof of semantic equivalence between FRETish specifications and their temporal logic counterparts computed by Fret. The complete formalization and the proof have been developed in the Prototype Verification System (PVS) theorem prover.
- 11 January 2022
- Published by Association for Computing Machinery (ACM)
- p. 68-81
Open AccessA compositional proof framework for FRETish requirements
Structured natural languages provide a trade space between ambiguous natural languages that make up most written requirements, and mathematical formal specifications such as Linear Temporal Logic. FRETish is a structured natural language for the elicitation of system requirements developed at NASA. The related open-source tool Fret provides support for translating FRETish requirements into temporal logic formulas that can be input to several verification and analysis tools. In the context of safety-critical systems, it is crucial to ensure that a generated formula captures the semantics of the corresponding FRETish requirement precisely. This paper presents a rigorous formalization of the FRETish language including a new denotational semantics and a proof of semantic equivalence between FRETish specifications and their temporal logic counterparts computed by Fret. The complete formalization and the proof have been developed in the Prototype Verification System (PVS) theorem prover.
- Open Access
A Compositional Proof Framework for FRETish Requirements
Structured natural languages provide a trade space between ambiguous natural languages that make up most written requirements and mathematical formal specifications such as Linear Temporal Logic. FRETish is a structured natural language for the elicitation of system requirements developed at NASA. The related open-source tool Fret provides support for translating FRETish requirements into temporal logic formulas that can be input to several verification and analysis tools. In the context of safety-critical systems, it is crucial to ensure that a generated formula captures the semantics of the corresponding FRETish requirement precisely. This paper presents a rigorous formalization of the FRETish language including a new denotational semantics and a proof of semantic equivalence between FRETish specifications and their temporal logic counterparts computed by Fret. The complete formalization and the proof have been developed in the Prototype Verification System (PVS) theorem prover.
Open AccessA Compositional Proof Framework for FRETish Requirements
Structured natural languages provide a trade space between ambiguous natural languages that make up most written requirements and mathematical formal specifications such as Linear Temporal Logic. FRETish is a structured natural language for the elicitation of system requirements developed at NASA. The related open-source tool Fret provides support for translating FRETish requirements into temporal logic formulas that can be input to several verification and analysis tools. In the context of safety-critical systems, it is crucial to ensure that a generated formula captures the semantics of the corresponding FRETish requirement precisely. This paper presents a rigorous formalization of the FRETish language including a new denotational semantics and a proof of semantic equivalence between FRETish specifications and their temporal logic counterparts computed by Fret. The complete formalization and the proof have been developed in the Prototype Verification System (PVS) theorem prover.
- 13 November 2020
- Published by Springer Nature
- p. 141-159
Automatic Generation of Guard-Stable Floating-Point Code
- 13 November 2020
- Published by Springer Nature
- p. 141-159
Automatic Generation of Guard-Stable Floating-Point Code
- Open Access
Automatic generation and verification of test-stable floating-point code
Test instability in a floating-point program occurs when the control flow of the program diverges from its ideal execution assuming real arithmetic. This phenomenon is caused by the presence of round-off errors that affect the evaluation of arithmetic expressions occurring in conditional statements. Unstable tests may lead to significant errors in safety-critical applications that depend on numerical computations. Writing programs that take into consideration test instability is a difficult task that requires expertise on finite precision computations and rounding errors. This paper presents a toolchain to automatically generate and verify a provably correct test-stable floating-point program from a functional specification in real arithmetic. The input is a real-valued program written in the Prototype Verification System (PVS) specification language and the output is a transformed floating-point C program annotated with ANSI/ISO C Specification Language (ACSL) contracts. These contracts relate the floating-point program to its functional specification in real arithmetic. The transformed program detects if unstable tests may occur and, in these cases, issues a warning and terminate. An approach that combines the Frama-C analyzer, the PRECiSA round-off error estimator, and PVS is proposed to automatically verify that the generated program code is correct in the sense that, if the program terminates without a warning, it follows the same computational path as its real-valued functional specification.
Open AccessAutomatic generation and verification of test-stable floating-point code
Test instability in a floating-point program occurs when the control flow of the program diverges from its ideal execution assuming real arithmetic. This phenomenon is caused by the presence of round-off errors that affect the evaluation of arithmetic expressions occurring in conditional statements. Unstable tests may lead to significant errors in safety-critical applications that depend on numerical computations. Writing programs that take into consideration test instability is a difficult task that requires expertise on finite precision computations and rounding errors. This paper presents a toolchain to automatically generate and verify a provably correct test-stable floating-point program from a functional specification in real arithmetic. The input is a real-valued program written in the Prototype Verification System (PVS) specification language and the output is a transformed floating-point C program annotated with ANSI/ISO C Specification Language (ACSL) contracts. These contracts relate the floating-point program to its functional specification in real arithmetic. The transformed program detects if unstable tests may occur and, in these cases, issues a warning and terminate. An approach that combines the Frama-C analyzer, the PRECiSA round-off error estimator, and PVS is proposed to automatically verify that the generated program code is correct in the sense that, if the program terminates without a warning, it follows the same computational path as its real-valued functional specification.
- 23 September 2019
- Published by Springer Nature
- p. 21-37
Provably Correct Floating-Point Implementation of a Point-in-Polygon Algorithm
- 23 September 2019
- Published by Springer Nature
- p. 21-37
Provably Correct Floating-Point Implementation of a Point-in-Polygon Algorithm