Ivan Perez

Ivan Perez

Auto-generated profile, based on publicly available information

Ivan Perez

KBR @ NASA Ames Research Center

Research Focus & Metrics

Academic Career Length

9Years (2018-Present)

(Calculated once Scilit publication data is synced: current year − year of first publication + 1)

Representative Publications

View All Publications
30 March 2022
Verified
Book Chapter
Open access
PDF file
IPIvan Perez
Ivan Perez
AMAnastasia Mavridou
Anastasia Mavridou
TPTom Pressburger
Tom Pressburger
AGAlwyn Goodloe
Alwyn Goodloe
DGDimitra Giannakopoulou
Dimitra Giannakopoulou
Runtime verification (RV) enables monitoring systems at runtime, to detect property violations early and limit their potential consequences. This paper presents an end-to-end framework to capture requirements in structured natural language and generate monitors that capture their semantics faithfully. We leverage NASA’s Formal Requirement Elicitation Tool (fret), and the RV systemCopilot. We extendfretwith mechanisms to capture additional information needed to generate monitors, and introduceOgma, a new tool to bridge the gap betweenfretandCopilot. With this framework, users can write requirements in an intuitive format and obtain real-time C monitors suitable for use in embedded systems. Our toolchain is available as open source.

17 September 2018
Verified
Conference Paper
Open access
PDF file
MBManuel Bärenz
Manuel Bärenz
IPIvan Perez
Ivan Perez

27 September 2022 in Electronic Proceedings in Theoretical Computer Science
Verified
Journal Article
Open access
PDF file
IPIvan Perez
Ivan Perez
AMAnastasia Mavridou
Anastasia Mavridou
TPTom Pressburger
Tom Pressburger
AWAlexander Will
Alexander Will
PMPatrick J. Martin
Patrick J. Martin

30 August 2023 in Proceedings of the ACM on Programming Languages
Verified
Journal Article
Open access
RSRyan G. Scott
Ryan G. Scott
MDMike Dodds
Mike Dodds
IPIvan Perez
Ivan Perez
AGAlwyn E. Goodloe
Alwyn E. Goodloe
RDRobert Dockins
Robert Dockins
When runtime verification is used to monitor safety-critical systems, it is essential that monitoring code behaves correctly. The Copilot runtime verification framework pursues this goal by automatically generating C monitor programs from a high-level DSL embedded in Haskell. In safety-critical domains, every piece of deployed code must be accompanied by an assurance argument that is convincing to human auditors. However, it is difficult for auditors to determine with confidence that a compiled monitor cannot crash and implements the behavior required by the Copilot semantics. In this paper we describe CopilotVerifier, which runs alongside the Copilot compiler, generating a proof of correctness for the compiled output. The proof establishes that a given Copilot monitor and its compiled form produce equivalent outputs on equivalent inputs, and that they either crash in identical circumstances or cannot crash. The proof takes the form of a bisimulation broken down into a set of verification conditions. We leverage two pieces of SMT-backed technology: the Crucible symbolic execution library for LLVM and the What4 solver interface library. Our results demonstrate that dramatically increased compiler assurance can be achieved at moderate cost by building on existing tools. This paves the way to our ultimate goal of generating formal assurance arguments that are convincing to human auditors.

7 May 2020 in Journal of Functional Programming
Verified
Journal Article
Open access
PDF file
IPIvan Perez
Ivan Perez
AGAlwyn E. Goodloe
Alwyn E. Goodloe
Highly critical application domains, like medicine and aerospace, require the use of strict design, implementation, and validation techniques. Functional languages have been used in these domains to develop synchronous dataflow programming languages for reactive systems. Causal stream functions and functional reactive programming (FRP) capture the essence of those languages in a way that is both elegant and robust. To guarantee that critical systems can operate under high stress over long periods of time, these applications require clear specifications of possible faults and hazards, and how they are being handled. Modeling failure is straightforward in functional languages, and many functional reactive abstractions incorporate support for failure or termination. However, handling unknown types of faults , and incorporating fault tolerance into FRP, requires a different construction and remains an open problem. This work demonstrates how to extend an existing functional reactive framework with fault tolerance features. At value level, we tag faulty signals with reliability and probability information and use random testing to inject faults and validate system properties encoded in temporal logic. At type level, we tag components with the kinds of faults they may exhibit and use type-level programming to obtain compile-time guarantees of key aspects of fault tolerance. Our approach is powerful enough to be used in systems with realistic complexity, and flexible enough to be used to guide system analysis and design, validate system properties in the presence of faults, perform runtime monitoring, and study the effects of different fault tolerance mechanisms.

13 September 2024
Verified
Book Chapter
Open access
PDF file
IPIvan Perez
Ivan Perez
AGAlwyn E. Goodloe
Alwyn E. Goodloe
FDFrank Dedden
Frank Dedden
Ultra-critical systems require high-level assurance, which cannot always be guaranteed at compile time. The use of runtime verification (RV) enables monitoring of these systems during runtime, to detect illegal states early and limit their potential consequences. This paper is a tutorial on RV using Copilot, an open-source runtime verification framework actively used by NASA to carry out experiments with robots and unmanned aerial vehicles. Copilot monitors are written in a compositional, stream-based language, which the framework automatically translates into real-time C code that satisfies static memory requirements suitable to run on embedded hardware. Copilot includes multiple libraries that extend the core functionality with higher-level constructs, Boyer-Moore majority voting, and a variety of Temporal Logics (TL), resulting in robust, high-level specifications that are easier to understand than their traditional counterparts.