Results 11  20
of
98
Ats: A language that combines programming with theorem proving
 of Lecture Notes in Computer Science
, 2005
"... Abstract. ATS is a language with a highly expressive type system that supports a restricted form of dependent types in which programs are not allowed to appear in type expressions. The language is separated into two components: a proof language in which (inductive) proofs can be encoded as (total re ..."
Abstract

Cited by 13 (0 self)
 Add to MetaCart
Abstract. ATS is a language with a highly expressive type system that supports a restricted form of dependent types in which programs are not allowed to appear in type expressions. The language is separated into two components: a proof language in which (inductive) proofs can be encoded as (total recursive) functions that are erased before execution, and a programming language for constructing programs to be evaluated. This separation enables a paradigm that combines programming with theorem proving. In this paper, we illustrate by example how this programming paradigm is supported in ATS.
Programming With Types
 CORNELL UNIVERSITY
, 2002
"... Runtime type analysis is an increasingly important linguistic mechanism in modern programming languages. Language runtime systems use it to implement services such as accurate garbage collection, serialization, cloning and structural equality. Component frameworks rely on it to provide reflection m ..."
Abstract

Cited by 11 (1 self)
 Add to MetaCart
Runtime type analysis is an increasingly important linguistic mechanism in modern programming languages. Language runtime systems use it to implement services such as accurate garbage collection, serialization, cloning and structural equality. Component frameworks rely on it to provide reflection mechanisms so they may discover and interact with program interfaces dynamically. Runtime type analysis is also crucial for large, distributed systems that must be dynamically extended, because it allows those systems to check program invariants when new code and new forms of data are added. Finally, many generic userlevel algorithms for iteration, pattern matching, and unification can be defined through type analysis mechanisms. However, existing frameworks for runtime type analysis were designed for simple type systems. They do not scale well to the sophisticated type systems of modern and nextgeneration programming languages that include complex constructs such as firstclass abstract types, recursive types, objects, and type parameterization. In addition, facilities to support type analysis often require complicated
Monotone Inductive and Coinductive Constructors of Rank 2
 Proceedings of CSL 2001
, 2001
"... A generalization of positive inductive and coinductive types to monotone inductive and coinductive constructors of rank 1 and rank 2 is described. The motivation is taken from initial algebras and nal coalgebras in a functor category and the CurryHowardcorrespondence. The denition of the system as ..."
Abstract

Cited by 10 (4 self)
 Add to MetaCart
A generalization of positive inductive and coinductive types to monotone inductive and coinductive constructors of rank 1 and rank 2 is described. The motivation is taken from initial algebras and nal coalgebras in a functor category and the CurryHowardcorrespondence. The denition of the system as a calculus requires an appropriate denition of monotonicity to overcome subtle problems, most notably to ensure that the (co)inductive constructors introduced via monotonicity of the underlying constructor of rank 2 are also monotone as constructors of rank 1. The problem is solved, strong normalization shown, and the notion proven to be wide enough to cover even highly complex datatypes. 1
Semicontinuous sized types and termination
 In Zoltán Ésik, editor, Computer Science Logic, 20th International Workshop, CSL 2006, 15th Annual Conference of the EACSL
"... Abstract. Some typebased approaches to termination use sized types: an ordinal bound for the size of a data structure is stored in its type. A recursive function over a sized type is accepted if it is visible in the type system that recursive calls occur just at a smaller size. This approach is onl ..."
Abstract

Cited by 10 (5 self)
 Add to MetaCart
Abstract. Some typebased approaches to termination use sized types: an ordinal bound for the size of a data structure is stored in its type. A recursive function over a sized type is accepted if it is visible in the type system that recursive calls occur just at a smaller size. This approach is only sound if the type of the recursive function is admissible, i.e., depends on the size index in a certain way. To explore the space of admissible functions in the presence of higherkinded data types and impredicative polymorphism, a semantics is developed where sized types are interpreted as functions from ordinals into sets of strongly normalizing terms. It is shown that upper semicontinuity of such functions is a sufficient semantic criterion for admissibility. To provide a syntactical criterion, a calculus for semicontinuous functions is developed. 1.
New Notions of Reduction and NonSemantic Proofs of Strong βNormalization in Typed λCalculi
 PROCEEDINGS OF LOGIC IN COMPUTER SCIENCE
, 1995
"... Two notions of reduction for terms of the λcalculus are introduced and the question of whether a λterm is βstrongly normalizing is reduced to the question of whether a λterm is merely normalizing under one of the notions of reduction. This gives a method to prove strong βnormalization for typ ..."
Abstract

Cited by 9 (2 self)
 Add to MetaCart
Two notions of reduction for terms of the λcalculus are introduced and the question of whether a λterm is βstrongly normalizing is reduced to the question of whether a λterm is merely normalizing under one of the notions of reduction. This gives a method to prove strong βnormalization for typed λcalculi. Instead of the usual semantic proof style based on Tait's realizability or Girard's "candidats de réductibilité", termination can be proved using a decreasing metric over a wellfounded ordering. This proof method is applied to the simplytyped λcalculus and the system of intersection types, giving the first nonsemantic proof for a polymorphic extension of the λcalculus.
Inductive Data Types: Wellordering Types Revisited
 Logical Environments
, 1992
"... We consider MartinLof's wellordering type constructor in the context of an impredicative type theory. We show that the wellordering types can represent various inductive types faithfully in the presence of the fillingup equality rules or jrules. We also discuss various properties of the ..."
Abstract

Cited by 8 (1 self)
 Add to MetaCart
We consider MartinLof's wellordering type constructor in the context of an impredicative type theory. We show that the wellordering types can represent various inductive types faithfully in the presence of the fillingup equality rules or jrules. We also discuss various properties of the fillingup rules. 1 Introduction Type theory is on the edge of two disciplines, constructive logic and computer science. Logicians see type theory as interesting because it offers a foundation for constructive mathematics and its formalization. For computer scientists, type theory promises to provide a uniform framework for programs, proofs, specifications, and their development. From each perspective, incorporating a general mechanism for inductively defined data types into type theory is an important next step. Various typetheoretic approaches to inductive data types have been considered in the literature, both in MartinLof's predicative type theories (e.g., [ML84, Acz86, Dyb88, Dyb91, B...
MendlerStyle Inductive Types, Categorically
 NORDIC JOURNAL OF COMPUTING 6(1999), 343 361
, 1999
"... We present a basis for a categorytheoretic account of Mendlerstyle inductive types. The account is based on suitably defined concepts of Mendlerstyle algebra and algebra homomorphism; Mendlerstyle inductive types are identified with initial Mendlerstyle algebras. We use the identification to ob ..."
Abstract

Cited by 8 (4 self)
 Add to MetaCart
We present a basis for a categorytheoretic account of Mendlerstyle inductive types. The account is based on suitably defined concepts of Mendlerstyle algebra and algebra homomorphism; Mendlerstyle inductive types are identified with initial Mendlerstyle algebras. We use the identification to obtain a reduction of conventional inductive types to Mendlerstyle inductive types and a reduction in the presence of certain restricted existential types of Mendlerstyle inductive types to conventional inductive types.
The marriage of bisimulations and Kripke logical relations
 In POPL
, 2012
"... There has been great progress in recent years on developing effective techniques for reasoning about program equivalence in MLlike languages—that is, languages that combine features like higherorder functions, recursive types, abstract types, and general mutable references. Two of the most promine ..."
Abstract

Cited by 7 (5 self)
 Add to MetaCart
There has been great progress in recent years on developing effective techniques for reasoning about program equivalence in MLlike languages—that is, languages that combine features like higherorder functions, recursive types, abstract types, and general mutable references. Two of the most prominent types of techniques to have emerged are bisimulations and Kripke logical relations (KLRs). While both approaches are powerful, their complementary advantages have led us and other researchers to wonder whether there is an essential tradeoff between them. Furthermore, both approaches seem to suffer from fundamental limitations if one is interested in scaling them to interlanguage reasoning. In this paper, we propose relation transition systems (RTSs), which marry together some of the most appealing aspects of KLRs and bisimulations. In particular, RTSs show how bisimulations’ support for reasoning about recursive features via coinduction can be synthesized with KLRs ’ support for reasoning about local state via state transition systems. Moreover, we have designed RTSs to avoid the limitations of KLRs and bisimulations that preclude their generalization to interlanguage reasoning. Notably, unlike KLRs, RTSs are transitively composable.
Union and intersection types for secure protocol implementations
"... We present a new type system for verifying the security of cryptographic protocol implementations. The type system combines prior work on refinement types, with union, intersection, and polymorphic types, and with the novel ability to reason statically about the disjointness of types. The increased ..."
Abstract

Cited by 7 (1 self)
 Add to MetaCart
We present a new type system for verifying the security of cryptographic protocol implementations. The type system combines prior work on refinement types, with union, intersection, and polymorphic types, and with the novel ability to reason statically about the disjointness of types. The increased expressivity enables the analysis of important protocol classes that were previously out of scope for the typebased analyses of protocol implementations. In particular, our types can statically characterize: (i) more usages of asymmetric cryptography, such as signatures of private data and encryptions of authenticated data; (ii) authenticity and integrity properties achieved by showing knowledge of secret data; (iii) applications based on zeroknowledge proofs. The type system comes with a mechanized proof of correctness and an efficient typechecker.
Implementing a normalizer using sized heterogeneous types
 In Workshop on Mathematically Structured Functional Programming, MSFP
, 2006
"... In the simplytyped lambdacalculus, a hereditary substitution replaces a free variable in a normal form r by another normal form s of type a, removing freshly created redexes on the fly. It can be defined by lexicographic induction on a and r, thus, giving rise to a structurally recursive normalize ..."
Abstract

Cited by 7 (1 self)
 Add to MetaCart
In the simplytyped lambdacalculus, a hereditary substitution replaces a free variable in a normal form r by another normal form s of type a, removing freshly created redexes on the fly. It can be defined by lexicographic induction on a and r, thus, giving rise to a structurally recursive normalizer for the simplytyped lambdacalculus. We generalize this scheme to simultaneous substitutions, preserving its simple termination argument. We further implement hereditary simultaneous substitutions in a functional programming language with sized heterogeneous inductive types, Fωb, arriving at an interpreter whose termination can be tracked by the type system of its host programming language.