27,847 research outputs found
Towards correct-by-construction product variants of a software product line: GFML, a formal language for feature modules
Software Product Line Engineering (SPLE) is a software engineering paradigm
that focuses on reuse and variability. Although feature-oriented programming
(FOP) can implement software product line efficiently, we still need a method
to generate and prove correctness of all product variants more efficiently and
automatically. In this context, we propose to manipulate feature modules which
contain three kinds of artifacts: specification, code and correctness proof. We
depict a methodology and a platform that help the user to automatically produce
correct-by-construction product variants from the related feature modules. As a
first step of this project, we begin by proposing a language, GFML, allowing
the developer to write such feature modules. This language is designed so that
the artifacts can be easily reused and composed. GFML files contain the
different artifacts mentioned above.The idea is to compile them into FoCaLiZe,
a language for specification, implementation and formal proof with some
object-oriented flavor. In this paper, we define and illustrate this language.
We also introduce a way to compose the feature modules on some examples.Comment: In Proceedings FMSPLE 2015, arXiv:1504.0301
Second-Order Functions and Theorems in ACL2
SOFT ('Second-Order Functions and Theorems') is a tool to mimic second-order
functions and theorems in the first-order logic of ACL2. Second-order functions
are mimicked by first-order functions that reference explicitly designated
uninterpreted functions that mimic function variables. First-order theorems
over these second-order functions mimic second-order theorems universally
quantified over function variables. Instances of second-order functions and
theorems are systematically generated by replacing function variables with
functions. SOFT can be used to carry out program refinement inside ACL2, by
constructing a sequence of increasingly stronger second-order predicates over
one or more target functions: the sequence starts with a predicate that
specifies requirements for the target functions, and ends with a predicate that
provides executable definitions for the target functions.Comment: In Proceedings ACL2 2015, arXiv:1509.0552
Development of a Translator from LLVM to ACL2
In our current work a library of formally verified software components is to
be created, and assembled, using the Low-Level Virtual Machine (LLVM)
intermediate form, into subsystems whose top-level assurance relies on the
assurance of the individual components. We have thus undertaken a project to
build a translator from LLVM to the applicative subset of Common Lisp accepted
by the ACL2 theorem prover. Our translator produces executable ACL2 formal
models, allowing us to both prove theorems about the translated models as well
as validate those models by testing. The resulting models can be translated and
certified without user intervention, even for code with loops, thanks to the
use of the def::ung macro which allows us to defer the question of termination.
Initial measurements of concrete execution for translated LLVM functions
indicate that performance is nearly 2.4 million LLVM instructions per second on
a typical laptop computer. In this paper we overview the translation process
and illustrate the translator's capabilities by way of a concrete example,
including both a functional correctness theorem as well as a validation test
for that example.Comment: In Proceedings ACL2 2014, arXiv:1406.123
Formal Verification of an Iterative Low-Power x86 Floating-Point Multiplier with Redundant Feedback
We present the formal verification of a low-power x86 floating-point
multiplier. The multiplier operates iteratively and feeds back intermediate
results in redundant representation. It supports x87 and SSE instructions in
various precisions and can block the issuing of new instructions. The design
has been optimized for low-power operation and has not been constrained by the
formal verification effort. Additional improvements for the implementation were
identified through formal verification. The formal verification of the design
also incorporates the implementation of clock-gating and control logic. The
core of the verification effort was based on ACL2 theorem proving.
Additionally, model checking has been used to verify some properties of the
floating-point scheduler that are relevant for the correct operation of the
unit.Comment: In Proceedings ACL2 2011, arXiv:1110.447
Towards an Intelligent Tutor for Mathematical Proofs
Computer-supported learning is an increasingly important form of study since
it allows for independent learning and individualized instruction. In this
paper, we discuss a novel approach to developing an intelligent tutoring system
for teaching textbook-style mathematical proofs. We characterize the
particularities of the domain and discuss common ITS design models. Our
approach is motivated by phenomena found in a corpus of tutorial dialogs that
were collected in a Wizard-of-Oz experiment. We show how an intelligent tutor
for textbook-style mathematical proofs can be built on top of an adapted
assertion-level proof assistant by reusing representations and proof search
strategies originally developed for automated and interactive theorem proving.
The resulting prototype was successfully evaluated on a corpus of tutorial
dialogs and yields good results.Comment: In Proceedings THedu'11, arXiv:1202.453
The Validation of Speech Corpora
1.2 Intended audience........................
- …