128,096 research outputs found
Evaluation of automated decisionmaking methodologies and development of an integrated robotic system simulation. Appendix A: ROBSIM user's guide
The purpose of the Robotics Simulation Program is to provide a broad range of computer capabilities to assist in the design, verification, simulation, and study of robotics systems. ROBSIM is program in FORTRAN 77 for use on a VAX 11/750 computer under the VMS operating system. This user's guide describes the capabilities of the ROBSIM programs, including the system definition function, the analysis tools function and the postprocessor function. The options a user may encounter with each of these executables are explained in detail and the different program prompts appearing to the user are included. Some useful suggestions concerning the appropriate answers to be given by the user are provided. An example user interactive run in enclosed for each of the main program services, and some of the capabilities are illustrated
Verifying an interactive consistency circuit: A case study in the reuse of a verification technology
The work done at ORA for NASA-LRC in the design and formal verification of a hardware implementation of a scheme for attaining interactive consistency (byzantine agreement) among four microprocessors is presented in view graph form. The microprocessors used in the design are an updated version of a formally verified 32-bit, instruction-pipelined, RISC processor, MiniCayuga. The 4-processor system, which is designed under the assumption that the clocks of all the processors are synchronized, provides software control over the interactive consistency operation. Interactive consistency computation is supported as an explicit instruction on each of the microprocessors. An identical user program executing on each of the processors decides when and on what data interactive consistency must be performed. This exercise also served as a case study to investigate the effectiveness of reusing the technology which was developed during the MiniCayuga effort for verifying synchronous hardware designs. MiniCayuga was verified using the verification system Clio which was also developed at ORA. To assist in reusing this technology, a computer-aided specification and verification tool was developed. This tool specializes Clio to synchronous hardware designs and significantly reduces the tedium involved in verifying such designs. The tool is presented and how it was used to specify and verify the interactive consistency circuit is described
Large liquid rocket engine transient performance simulation system
Phase 1 of the Rocket Engine Transient Simulation (ROCETS) program consists of seven technical tasks: architecture; system requirements; component and submodel requirements; submodel implementation; component implementation; submodel testing and verification; and subsystem testing and verification. These tasks were completed. Phase 2 of ROCETS consists of two technical tasks: Technology Test Bed Engine (TTBE) model data generation; and system testing verification. During this period specific coding of the system processors was begun and the engineering representations of Phase 1 were expanded to produce a simple model of the TTBE. As the code was completed, some minor modifications to the system architecture centering on the global variable common, GLOBVAR, were necessary to increase processor efficiency. The engineering modules completed during Phase 2 are listed: INJTOO - main injector; MCHBOO - main chamber; NOZLOO - nozzle thrust calculations; PBRNOO - preburner; PIPE02 - compressible flow without inertia; PUMPOO - polytropic pump; ROTROO - rotor torque balance/speed derivative; and TURBOO - turbine. Detailed documentation of these modules is in the Appendix. In addition to the engineering modules, several submodules were also completed. These submodules include combustion properties, component performance characteristics (maps), and specific utilities. Specific coding was begun on the system configuration processor. All functions necessary for multiple module operation were completed but the SOLVER implementation is still under development. This system, the Verification Checkout Facility (VCF) allows interactive comparison of module results to store data as well as provides an intermediate checkout of the processor code. After validation using the VCF, the engineering modules and submodules were used to build a simple TTBE
An Implementation of Separation Logic in Coq
For certain applications, the correctness of software involved is crucial, particularly if
human life is in danger. In order to achieve correctness, common practice is to gather
evidence for program correctness by testing the system. Even though testing may find
certain errors in the code, it cannot guarantee that the program is error-free. The program
of formal verification is the act of proving or disproving the correctness of the system with
respect to a formal specification. A logic for program verification is the so-called Hoare
Logic. Hoare Logic can deal with programs that do not utilize pointers, i.e., it allows
reasoning about programs that do not use shared mutable data structures. Separation Logic
extends Hoare logic that allows pointers, including pointer arithmetic, in the programming
language. It has four-pointer manipulating commands which perform the heap operations
such as lookup, allocation, deallocation, and mutation. We introduce an implementation of
separation logic in the interactive proof system Coq. Besides verifying that separation logic
is correct, we will provide several examples of programs and their correctness proof
An Evaluation of the ABEL System
This thesis evaluates and discusses the ABEL system, an interactive
theorem prover, developed at the Department of Informatics at the
University of Oslo. The ABEL system is ultimately intended to be an
environment for program development, including program verification,
and is built on the work of Ole-Johan Dahl in the field of formal
specification and verification.
A review of the necessary background theory is given, including short
descriptions of some other theorem provers and verification systems.
The review also includes explanations of the most prevalent techniques
for mechanised theorem proving.
Additionally, the thesis contains a user's guide to the system, meant
to help new users of the ABEL system getting started.
Some tests of the proof system is performed, wherein its performance
with respect to the needs of program verification is investigated. An
evaluation is performed, and conclusions drawn on what the system's
main weaknesses are. Finally, with this evaluation as background,
suggestions are made on how to develop the system further into a true
verification system
Specification of Adleman’s Restricted Model Using an Automated Reasoning System: Verification of Lipton’s Experiment
The aim ofthis paper is to develop an executable prototype
ofan unconventional model ofcomputation. Using the PVS verification
system (an interactive environment for writing formal specifications
and checking formal proofs), we formalize the restricted model, based on
DNA, due to L. Adleman. Also, we design a formal molecular program in
this model that solves SAT following Lipton’s ideas.We prove using PVS
the soundness and completeness ofthis molecular program. This work
is intended to give an approach to the opportunities offered by mechanized
analysis ofuncon ventional model ofcomputation in general. This
approach opens up new possibilities ofv erifying molecular experiments
before implementing them in a laboratory.Ministerio de Educación y Cultura TIC2000-1368-C03-02Ministerio de Educación y Cultura PB96-134
Mechanical Verification of Interactive Programs Specified by Use Cases
International audienceInteractive programs, like user interfaces, are hard to formally specify and thus to prove correct. Some ideas coming from functional programming languages have been successful to improve the way we write safer programs, compared to traditional imperative languages, but these ideas mostly apply to code fragments without any inputs–outputs. Using the purely functional language Coq, we present a new technique to represent interactive programs and formally verify use cases using the Coq proof engine as a symbolic debugger. To this end we introduce the notion of scenarios, well-typed schema of interactions between an environment and a program. We design and certify a blog system as an illustration. Our approach generalizes unit-testing techniques and outlines a new method for mechanically assisted checking of effectful functional programs. I. Introduction Implementing and proving correct interactive programs is challenging. Indeed, interactive programs are hard to reason about because they communicate with an outer environment (the operating system, the network, the user,. . .) which may be under-specified and non determin-istic. Moreover, the communications between the program and the environment can happen at many points during the execution and may depend on previous interactions. Many techniques have been developed to model, specify and prove correct interactive or concurrent programs[15]. For instance, process algebra and temporal logics are well understood abstract models for such programs. In these abstract models, some interesting behavioral properties can be automatically proved by model-checkers. Yet, these tools usually provide guarantees about the model of the program, not its actual implementation. In another approach, called software-proof co-design, the specification and the verification of a program is not disconnected from its actual implementation. In that case, specifying, implementing and verifying are tightly interleaved in the software development process. This tight integration is possible within the Coq proof assistant which is both a programming language and an assisted prover. Yet, even if a realistic compiler for the C language has already been developed in Coq[12], using Coq as a general purpose programming language may be considere
- …