Results 11  20
of
35
A Comparison of Formalizations of the MetaTheory of a Language with Variable Bindings in Isabelle
 Supplemental Proceedings of the 14th International Conference on Theorem Proving in Higher Order Logics
, 2001
"... Abstract. Theorem provers can be used to reason formally about programming languages and there are various general methods for the formalization of variable binding operators. Hence there are choices for the style of formalization of such languages, even within a single theorem prover. The choice of ..."
Abstract

Cited by 6 (2 self)
 Add to MetaCart
(Show Context)
Abstract. Theorem provers can be used to reason formally about programming languages and there are various general methods for the formalization of variable binding operators. Hence there are choices for the style of formalization of such languages, even within a single theorem prover. The choice of formalization can affect how easy or difficult it is to do automated reasoning. The aim of this paper is to compare and contrast three formalizations (termed de Bruijn, weak HOAS and full HOAS) of a typical functional programming language. Our contribution is a detailed report on our formalizations, a survey of related work, and a final comparative summary, in which we mention a novel approach to a hybrid de Bruijn/HOAS syntax. 1
Formalizing Arrow’s theorem
"... Abstract. We present a small project in which we encoded a proof of Arrow’s theorem – probably the most famous results in the economics field of social choice theory – in the computer using the Mizar system. We both discuss the details of this specific project, as well as describe the process of for ..."
Abstract

Cited by 5 (0 self)
 Add to MetaCart
Abstract. We present a small project in which we encoded a proof of Arrow’s theorem – probably the most famous results in the economics field of social choice theory – in the computer using the Mizar system. We both discuss the details of this specific project, as well as describe the process of formalization (encoding proofs in the computer) in general. Keywords: formalization of mathematics, Mizar, social choice theory, Arrow’s theorem, GibbardSatterthwaite theorem, proof errors.
Certifying Term Rewriting Proofs in ELAN
, 2001
"... Term rewriting has been shown to be a good environment for both programming and proving. For analysing and debugging rulebased programs, we propose in this work a formalism based on the rewriting calculus with explicit substitutions ( calculus). This formalism also allows us to build the proof ter ..."
Abstract

Cited by 4 (0 self)
 Add to MetaCart
Term rewriting has been shown to be a good environment for both programming and proving. For analysing and debugging rulebased programs, we propose in this work a formalism based on the rewriting calculus with explicit substitutions ( calculus). This formalism also allows us to build the proof terms of rewriting derivations. Therefore, term rewriting proofs can be exported to other systems by translating them into the corresponding syntaxes. That is, using a proof checker, one can certify these proofs and vice versa, this method allows us to get term rewriting in proof assistants using an external system. Our method not only works with syntactic rewriting but also with rewriting modulo a set of axioms (e.g. associativitycommutativity).
A certified implementation of ML with structural polymorphism
 In Proceedings of the 8th Asian conference on Programming Languages and Systems, APLAS’10
, 2010
"... Abstract. The type system of Objective Caml has many unique features, which make ensuring the correctness of its implementation difficult. One of these features is structurally polymorphic types, such as polymorphic object and variant types, which have the extra specificity of allowing recursion. We ..."
Abstract

Cited by 3 (1 self)
 Add to MetaCart
(Show Context)
Abstract. The type system of Objective Caml has many unique features, which make ensuring the correctness of its implementation difficult. One of these features is structurally polymorphic types, such as polymorphic object and variant types, which have the extra specificity of allowing recursion. We implemented in Coq a certified interpreter for Core ML extended with structural polymorphism and recursion. Along with type soundness of evaluation, soundness and principality of type inference are also proved. 1
Typed syntactic metaprogramming
 International Conference on Functional Programming (ICFP
, 2013
"... We present a novel set of metaprogramming primitives for use in a dependentlytyped functional language. The types of our metaprograms provide strong and precise guarantees about their termination, correctness and completeness. Our system supports typesafe construction and analysis of terms, typ ..."
Abstract

Cited by 3 (0 self)
 Add to MetaCart
(Show Context)
We present a novel set of metaprogramming primitives for use in a dependentlytyped functional language. The types of our metaprograms provide strong and precise guarantees about their termination, correctness and completeness. Our system supports typesafe construction and analysis of terms, types and typing contexts. Unlike alternative approaches, they are written in the same style as normal programs and use the language’s standard functional computational model. We formalise the new metaprogramming primitives, implement them as an extension of Agda, and provide evidence of usefulness by means of two compelling applications in the fields of datatypegeneric programming and proof tactics.
Practical Inference for TypedBased Termination in a Polymorphic Setting
"... We introduce a polymorphic #calculus that features inductive types and that enforces termination of recursive definitions through typing. Then, we define a sound and complete type inference algorithm that computes a set of constraints to be satisfied for terms to be typable. ..."
Abstract

Cited by 3 (0 self)
 Add to MetaCart
We introduce a polymorphic #calculus that features inductive types and that enforces termination of recursive definitions through typing. Then, we define a sound and complete type inference algorithm that computes a set of constraints to be satisfied for terms to be typable.
Specifying in Coq inheritance used in Computer Algebra Libraries
, 2000
"... This paper is part of FOC[3] a project for developing Computer Algebra libraries, certified in Coq [2]. FOC has developed a methodology for programming Computer Algebra libraries, using modules and objects in Ocaml. In order to specify modularity features used by FOC in Ocaml, we are coding in Coq a ..."
Abstract

Cited by 3 (0 self)
 Add to MetaCart
This paper is part of FOC[3] a project for developing Computer Algebra libraries, certified in Coq [2]. FOC has developed a methodology for programming Computer Algebra libraries, using modules and objects in Ocaml. In order to specify modularity features used by FOC in Ocaml, we are coding in Coq a theory for extensible records with dependent fields. This theory intends to express especially the kind of inheritance with method redefinition and late binding, that FOC uses in its Ocaml programs. The unit of FOC are coded as records. As we want to encode semantic information on units, the fields of our records may be proofs. Thus, our fields may depend on each others. We called them Drecords. Then, we introduce a new datatype, called mixDrec, to represent FOC classes. Actually, mixDrecs are useful for describing a hierarchy of Drecords in a incremental way. In mixDrecs, fields can be only declared or they can be redefined. MixDrecs can be extended by inheritance.
Extracting a normalization algorithm in Isabelle/HOL
 TYPES FOR PROOFS AND PROGRAMS, INTERNATIONAL WORKSHOP, TYPES 2004, JOUYENJOSAS
, 2004
"... We present a formalization of a constructive proof of weak normalization for the simplytyped λcalculus in the theorem prover Isabelle/HOL, and show how a program can be extracted from it. Unlike many other proofs of weak normalization based on Tait’s strong computability predicates, which require ..."
Abstract

Cited by 2 (1 self)
 Add to MetaCart
We present a formalization of a constructive proof of weak normalization for the simplytyped λcalculus in the theorem prover Isabelle/HOL, and show how a program can be extracted from it. Unlike many other proofs of weak normalization based on Tait’s strong computability predicates, which require a logic supporting strong eliminations and can give rise to dependent types in the extracted program, our formalization requires only relatively simple proof principles. Thus, the program obtained from this proof is typable in simplytyped higherorder logic as implemented in Isabelle/HOL, and a proof of its correctness can automatically be derived within the system.
Utrecht University and
, 2013
"... This paper presents a library for programming with polymorphic dynamic types in the dependently typed programming language Agda. The resulting library allows dynamically typed values with a polymorphic type to be instantiated to a less general (possibly monomorphic) type without compromising type s ..."
Abstract
 Add to MetaCart
(Show Context)
This paper presents a library for programming with polymorphic dynamic types in the dependently typed programming language Agda. The resulting library allows dynamically typed values with a polymorphic type to be instantiated to a less general (possibly monomorphic) type without compromising type soundness. There are situations where the types of the values that a program manipulates are not known during compilation. This is typically the case when data, or even parts of the program itself, are obtained by interacting with the ‘outside ’ world: when values are exchanged between applications by deserialization from disk, input is provided by a user, or part of a program is obtained over a network connection. Modern statically typed functional languages, such as Clean (van Eekelen et al., 1990), Haskell (Peyton Jones, 2003), and OCaml (Leroy et al., 2011), all support some form of dynamic typing, that allows programmers to defer type checking until runtime. These languages define a special type for dynamically typed values. We will abbreviate such dynamically typed values to dynamic value or just dynamic. A dynamically typed value