2,479 research outputs found
Constraining Montague Grammar for computational applications
This work develops efficient methods for the implementation of Montague Grammar on
a computer. It covers both the syntactic and the semantic aspects of that task. Using a
simplified but adequate version of Montague Grammar it is shown how to translate from
an English fragment to a purely extensional first-order language which can then be made
amenable to standard automatic theorem-proving techniques.
Translating a sentence of Montague English into the first-order predicate calculus
usually proceeds via an intermediate translation in the typed lambda calculus which is
then simplified by lambda-reduction to obtain a first-order equivalent. If sufficient sortal
structure underlies the type theory for the reduced translation to always be a first-order
one then perhaps it should be directly constructed during the syntactic analysis of the
sentence so that the lambda-expressions never come into existence and no further
processing is necessary. A method is proposed to achieve this involving the unification
of meta-logical expressions which flesh out the type symbols of Montague's type theory
with first-order schemas.
It is then shown how to implement Montague Semantics without using a theorem prover
for type theory. Nothing more than a theorem prover for the first-order predicate
calculus is required. The first-order system can be used directly without encoding the
whole of type theory. It is only necessary to encode a part of second-order logic and
this can be done in an efficient, succinct, and readable manner. Furthermore the
pseudo-second-order terms need never appear in any translations provided by the parser.
They are vital just when higher-order reasoning must be simulated.
The foundation of this approach is its five-sorted theory of Montague Semantics. The
objects in this theory are entities, indices, propositions, properties, and quantities. It is a
theory which can be expressed in the language of first-order logic by means of axiom
schemas and there is a finite second-order axiomatisation which is the basis for the
theorem-proving arrangement. It can be viewed as a very constrained set theory
Confluence via strong normalisation in an algebraic \lambda-calculus with rewriting
The linear-algebraic lambda-calculus and the algebraic lambda-calculus are
untyped lambda-calculi extended with arbitrary linear combinations of terms.
The former presents the axioms of linear algebra in the form of a rewrite
system, while the latter uses equalities. When given by rewrites, algebraic
lambda-calculi are not confluent unless further restrictions are added. We
provide a type system for the linear-algebraic lambda-calculus enforcing strong
normalisation, which gives back confluence. The type system allows an abstract
interpretation in System F.Comment: In Proceedings LSFA 2011, arXiv:1203.542
Adequacy of compositional translations for observational semantics
We investigate methods and tools for analysing translations between programming languages with respect to observational semantics. The behaviour of programs is observed in terms of may- and must-convergence in arbitrary contexts, and adequacy of translations, i.e., the reflection of program equivalence, is taken to be the fundamental correctness condition. For compositional translations we propose a notion of convergence equivalence as a means for proving adequacy. This technique avoids explicit reasoning about contexts, and is able to deal with the subtle role of typing in implementations of language extension
Conservativity of embeddings in the lambda Pi calculus modulo rewriting (long version)
The lambda Pi calculus can be extended with rewrite rules to embed any
functional pure type system. In this paper, we show that the embedding is
conservative by proving a relative form of normalization, thus justifying the
use of the lambda Pi calculus modulo rewriting as a logical framework for
logics based on pure type systems. This result was previously only proved under
the condition that the target system is normalizing. Our approach does not
depend on this condition and therefore also works when the source system is not
normalizing.Comment: Long version of TLCA 2015 pape
Applied Type System: An Approach to Practical Programming with Theorem-Proving
The framework Pure Type System (PTS) offers a simple and general approach to
designing and formalizing type systems. However, in the presence of dependent
types, there often exist certain acute problems that make it difficult for PTS
to directly accommodate many common realistic programming features such as
general recursion, recursive types, effects (e.g., exceptions, references,
input/output), etc. In this paper, Applied Type System (ATS) is presented as a
framework for designing and formalizing type systems in support of practical
programming with advanced types (including dependent types). In particular, it
is demonstrated that ATS can readily accommodate a paradigm referred to as
programming with theorem-proving (PwTP) in which programs and proofs are
constructed in a syntactically intertwined manner, yielding a practical
approach to internalizing constraint-solving needed during type-checking. The
key salient feature of ATS lies in a complete separation between statics, where
types are formed and reasoned about, and dynamics, where programs are
constructed and evaluated. With this separation, it is no longer possible for a
program to occur in a type as is otherwise allowed in PTS. The paper contains
not only a formal development of ATS but also some examples taken from
ats-lang.org, a programming language with a type system rooted in ATS, in
support of employing ATS as a framework to formulate advanced type systems for
practical programming
QPCF: higher order languages and quantum circuits
qPCF is a paradigmatic quantum programming language that ex- tends PCF with
quantum circuits and a quantum co-processor. Quantum circuits are treated as
classical data that can be duplicated and manipulated in flexible ways by means
of a dependent type system. The co-processor is essentially a standard QRAM
device, albeit we avoid to store permanently quantum states in between two
co-processor's calls. Despite its quantum features, qPCF retains the classic
programming approach of PCF. We introduce qPCF syntax, typing rules, and its
operational semantics. We prove fundamental properties of the system, such as
Preservation and Progress Theorems. Moreover, we provide some higher-order
examples of circuit encoding
- …