Inductively defined types

Coquand, Thierry; Paulin, Christine

doi:10.1007/3-540-52335-9_47

Cited by 206 publications

(157 citation statements)

References 14 publications

Supporting

Mentioning

157

Contrasting

Order By: Relevance

“…They are intended for web applications such as web IDEs 4 , "live" tutorial/documentation 5 and online exercises. We have used this infrastructure to develop course material for an interactive theorem proving course 6 being offered in the spring of 2015 at CMU.…”

Section: The User Interfacementioning

confidence: 99%

See 1 more Smart Citation

The Lean Theorem Prover (System Description)

Moura

Kong

Avigad

et al. 2015

Lecture Notes in Computer Science

272

147

View full text Add to dashboard Cite

Abstract. Lean is a new open source theorem prover being developed at Microsoft Research and Carnegie Mellon University, with a small trusted kernel based on dependent type theory. It aims to bridge the gap between interactive and automated theorem proving, by situating automated tools and methods in a framework that supports user interaction and the construction of fully specified axiomatic proofs. Lean is an ongoing and long-term effort, but it already provides many useful components, integrated development environments, and a rich API which can be used to embed it into other systems. It is currently being used to formalize category theory, homotopy type theory, and abstract algebra. We describe the project goals, system architecture, and main features, and we discuss applications and continuing work.

show abstract

Section: The User Interfacementioning

confidence: 99%

“…It can be instantiated with an impredicative sort or propositions, Prop, to provide a version of the Calculus of Inductive Constructions (CIC) [5,6]. Moreover, Prop can be marked proof-irrelevant if desired.…”

Section: Introductionmentioning

confidence: 99%

The Lean Theorem Prover (System Description)

Moura

Kong

Avigad

et al. 2015

Lecture Notes in Computer Science

272

147

View full text Add to dashboard Cite

show abstract

“…Many systems for reasoning about computations start with established inductive logic theorem provers such as Coq [10,8] and Isabelle/HOL [34], and then use those systems to build approaches to binding and substitution. Three such notable approaches are the locally nameless representation [1], the Nominal package for Isabelle/HOL [45], and Hybrid [11].…”

Section: Two-level Logicmentioning

confidence: 99%

Reasoning about Computations Using Two-Levels of Logic

Miller

2010

Programming Languages and Systems

View full text Add to dashboard Cite

Abstract. We describe an approach to using one logic to reason about specifications written in a second logic. One level of logic, called the "reasoning logic", is used to state theorems about computational specifications. This logic is classical or intuitionistic and should contain strong proof principles such as induction and co-induction. The second level of logic, called the "specification logic", is used to specify computation. While computation can be specified using a number of formal techniques-e.g., Petri nets, process calculus, and state machines-we shall illustrate the merits and challenges of using logic programming-like specifications of computation.

show abstract

“…We adopt the 'certified binaries' framework of Shao et al e ::= x | n | e 1 + e 2 | λ x.e | e 1 e 2 | e 1 , ..., e n | e 1 @ e 2 | e 1 @ e 2 ← e 3 | e e 1 , ..., e n | {l 1 = e 1 , ..., l n = e n } | e # l [ 30], in which the types and proofs that govern computations are defined within the Calculus of Inductive Constructions [11,12]. Our language has the same primitive operators as Links, so it is an appropriate target for efficient, type-preserving compilation of various forms of inheritance, even when the base class is unknown at compile time.…”

Section: Motivationmentioning

confidence: 99%

Typed Compilation Against Non-manifest Base Classes

League

Monnier

2006

Construction and Analysis of Safe, Secure, and Interoperable Smart Devices

View full text Add to dashboard Cite

Abstract. Much recent work on proof-carrying code aims to build certifying compilers for single-inheritance object-oriented languages, such as Java or C#. Some advanced object-oriented languages support compiling a derived class without complete information about its base class. This strategy-though necessary for supporting features such as mixins, traits, and first-class classes-is not wellsupported by existing typed intermediate languages. We present a low-level IL with a type system based on the Calculus of Inductive Constructions. It is an appropriate target for efficient, type-preserving compilation of various forms of inheritance, even when the base class is unknown at compile time. Languages (such as Java) that do not require such flexibility are not penalized for it at run time. MotivationIn most object-oriented languages, programmers factor their solutions over a hierarchy of classes. Since the classes in a hierarchy may appear in different compilation units, one question that the language designer (or implementer) must address is: how much information about a base class is needed to compile its derived class?With its emphasis on efficient object layout and method dispatch, C++ [32] requires complete information about the base class: the number, locations, and types of all its fields and methods. Indeed, it is because C++ depends on this information that a seemingly minor change to a base class triggers recompilation of all its descendents. Java [23] is somewhat more flexible. To support binary compatibility, its class files are not committed to a particular object layout. A derived class depends only on the names and types of the base class fields and methods that it uses. Nevertheless, most Java implementations ultimately compile classes to lower-level code using the same layouts and techniques as C++.A few modern object-oriented languages allow classes as module parameters (Moby [15], OCaml [28]) or as first-class values (Loom [5]). Other languages support more flexible forms of inheritance, such as mixins [24,3] and traits [29]. If a base class is not available for inspection when a derived class is compiled, we say the base class is not manifest. Implementations of these languages use a dictionary data structure to map method and field names to their locations in the object layout. The dictionary may be applied at link time or at run time, as required by the language.Here is a simple example in OCaml (although it could be expressed just as easily in Moby). We declare a signature for modules containing a circle class that implements Below, CircleBBox declares a class bbox that inherits from a (non-manifest) base class circle, overrides the area method (using a super call), and defines a new method bounds.module CircleBBox = functor (C : CIRCLE) -> struct class bbox arg = object (self) inherit C.circle arg as super method area = super#area * 4.0 / pi (* area of bbox *) method bounds = let (x,y) = self#center in let r = self#radius in ((x-r,y-r), (x+r,y+r)) end endTo compile this functor, we must mak...

show abstract

Inductively defined types

Cited by 206 publications

References 14 publications

The Lean Theorem Prover (System Description)

The Lean Theorem Prover (System Description)

Reasoning about Computations Using Two-Levels of Logic

Typed Compilation Against Non-manifest Base Classes

Contact Info

Product

Resources

About