Results 1 
8 of
8
Verifying safety properties with the TLA+ proof system
 In Jürgen Giesl and Reiner Hähnle, editors, Intl. Joint Conf. Automated Reasoning (IJCAR 2010), volume 6173 of Lecture Notes in Computer Science
, 2010
"... TLAPS, the TLA+ proof system, is a platform for the development and mechanical verification of TLA+ proofs. The TLA+ proof language is declarative, and understanding proofs requires little background beyond elementary mathematics. The language supports hierarchical and nonlinear proof construction ..."
Abstract

Cited by 17 (7 self)
 Add to MetaCart
(Show Context)
TLAPS, the TLA+ proof system, is a platform for the development and mechanical verification of TLA+ proofs. The TLA+ proof language is declarative, and understanding proofs requires little background beyond elementary mathematics. The language supports hierarchical and nonlinear proof construction and verification, and it is independent of any verification tool or strategy. Proofs are written in the same language as specifications; engineers do not have to translate their highlevel designs into the language of a particular verification tool. A proof manager interprets a TLA+ proof as a collection of proof obligations to be verified, which it sends to backend verifiers that include theorem provers, proof assistants, SMT solvers, and decision procedures. The first public release of TLAPS is available from [1], distributed with a BSDlike license. It handles almost all the nontemporal part of TLA+ as well as the temporal reasoning needed to prove standard safety properties, in particular invariance and step simulation, but not liveness properties. Intuitively, a safety property asserts what is permitted to happen; a liveness property asserts what must happen; for a more formal overview, see [3, 10]. 2
Formalizing the LogicAutomaton Connection
"... Abstract. This paper presents a formalization of a library for automata on bit strings in the theorem prover Isabelle/HOL. It forms the basis of a reflectionbased decision procedure for Presburger arithmetic, which is efficiently executable thanks to Isabelle’s code generator. With this work, we th ..."
Abstract

Cited by 10 (1 self)
 Add to MetaCart
(Show Context)
Abstract. This paper presents a formalization of a library for automata on bit strings in the theorem prover Isabelle/HOL. It forms the basis of a reflectionbased decision procedure for Presburger arithmetic, which is efficiently executable thanks to Isabelle’s code generator. With this work, we therefore provide a mechanized proof of the wellknown connection between logic and automata theory. 1
Proof reconstruction for firstorder logic and settheoretical constructions
 Sixth International Workshop on Automated Verification of Critical Systems (AVOCS ’06) – Preliminary Proceedings
, 2006
"... Proof reconstruction is a technique that combines an interactive theorem prover and an automatic one in a sound way, so that users benefit from the expressiveness of the first tool and the automation of the latter. We present an implementation of proof reconstruction for firstorder logic and setth ..."
Abstract

Cited by 3 (1 self)
 Add to MetaCart
(Show Context)
Proof reconstruction is a technique that combines an interactive theorem prover and an automatic one in a sound way, so that users benefit from the expressiveness of the first tool and the automation of the latter. We present an implementation of proof reconstruction for firstorder logic and settheoretical constructions between the interactive theorem prover Isabelle and the automatic SMT prover haRVey. 1
Parametric linear arithmetic over ordered fields in Isabelle/HOL
"... We use higherorder logic to verify a quantifier elimination procedure for linear arithmetic over ordered fields, where the coefficients of variables are multivariate polynomials over another set of variables, we call parameters. The procedure generalizes Ferrante and Rackoff’s algorithm for the non ..."
Abstract

Cited by 2 (0 self)
 Add to MetaCart
We use higherorder logic to verify a quantifier elimination procedure for linear arithmetic over ordered fields, where the coefficients of variables are multivariate polynomials over another set of variables, we call parameters. The procedure generalizes Ferrante and Rackoff’s algorithm for the nonparametric case. The formalization is based on axiomatic type classes and automatically carries over to e.g. the rational, real and nonstandard real numbers. It is executable, can be applied to HOL formulae by reflection and performs well on practical examples.
Reflecting Quantifier Elimination for Linear Arithmetic
"... Abstract. This paper formalizes and verifies quantifier elimination procedures for dense linear orders and for real and integer linear arithmetic in the theorem prover ..."
Abstract

Cited by 2 (1 self)
 Add to MetaCart
(Show Context)
Abstract. This paper formalizes and verifies quantifier elimination procedures for dense linear orders and for real and integer linear arithmetic in the theorem prover
SML with antiquotations embedded into Isabelle/Isar
"... Abstract. We report on some recent experiments with SML embedded into the Isabelle/Isar theory and proof language, such that the program text may again refer to formal logical entities via antiquotations. The meaning of our antiquotations within SML text observes the different logical environments a ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
Abstract. We report on some recent experiments with SML embedded into the Isabelle/Isar theory and proof language, such that the program text may again refer to formal logical entities via antiquotations. The meaning of our antiquotations within SML text observes the different logical environments at compile time, link time (of theory interpretations), and runtime (within proof procedures). As a general design principle we neither touch the logical foundations of Isabelle, nor the SML language implementation. Thus we achieve a modular composition of the programming language and the logic within the Isabelle/Isar framework. Our work should be understood as a continuation and elaboration of the original “LCF system approach”, which has introduced ML as a programming language for theorem proving in the first place. 1
Reflecting Linear Arithmetic: From Dense Linear Orders to Presburger Arithmetic
"... This talk presents reflected quantifier elimination procedures for both integer and real linear arithmetic. Reflection means that the algorithms are expressed as recursive functions on recursive data types inside some logic (in our case HOL), are verified in that logic, and can then be applied to th ..."
Abstract
 Add to MetaCart
This talk presents reflected quantifier elimination procedures for both integer and real linear arithmetic. Reflection means that the algorithms are expressed as recursive functions on recursive data types inside some logic (in our case HOL), are verified in that logic, and can then be applied to the logic itself. After a brief overview of reflection we will discuss a number of quantifier elimination algorithms for the following theories: – Dense linear orders without endpoints. We formalize the standard DNFbased algorithm from the literature. – Linear real arithmetic. We present both a DNFbased algorithm extending the case of dense linear orders and an optimized version of the algorithm by Ferrante and Rackoff [3]. – Presburger arithmetic. Again we show both a naive DNFbased algorithm and the DNFavoiding one by Cooper [2]. We concentrate on the algorithms and their formulation in Isabelle/HOL, using the concept of locales to allow modular definitions and verification. Some of the details can be found in joint work with Amine Chaib [1].
Trusted Extensions of Interactive Theorem Provers: Workshop Summary
"... Abstract. A fundamental strength of interactive theorem provers (ITPs) is the high degree of trust one can place in formalizations carried out in them. ITPs are usually also extensible, both at the logic level and at the implementation level. There is consequently a substantial body of existing and ..."
Abstract
 Add to MetaCart
(Show Context)
Abstract. A fundamental strength of interactive theorem provers (ITPs) is the high degree of trust one can place in formalizations carried out in them. ITPs are usually also extensible, both at the logic level and at the implementation level. There is consequently a substantial body of existing and ongoing research into the extension of ITPs while preserving trust. In order to survey existing and new work in this area, we organized the Trusted Extension of Interactive Theorem Provers (TEITP) workshop.1 As a result of the workshop we have been able to get an overview of the approaches taken by most of the major ITPs. In this document we summarize the meeting and provide some background information for readers unfamiliar with the area.