539,471 research outputs found
Extending Nunchaku to Dependent Type Theory
Nunchaku is a new higher-order counterexample generator based on a sequence
of transformations from polymorphic higher-order logic to first-order logic.
Unlike its predecessor Nitpick for Isabelle, it is designed as a stand-alone
tool, with frontends for various proof assistants. In this short paper, we
present some ideas to extend Nunchaku with partial support for dependent types
and type classes, to make frontends for Coq and other systems based on
dependent type theory more useful.Comment: In Proceedings HaTT 2016, arXiv:1606.0542
Categories with families and first-order logic with dependent sorts
First-order logic with dependent sorts, such as Makkai's first-order logic
with dependent sorts (FOLDS), or Aczel's and Belo's dependently typed
(intuitionistic) first-order logic (DFOL), may be regarded as logic enriched
dependent type theories. Categories with families (cwfs) is an established
semantical structure for dependent type theories, such as Martin-L\"of type
theory. We introduce in this article a notion of hyperdoctrine over a cwf, and
show how FOLDS and DFOL fit in this semantical framework. A soundness and
completeness theorem is proved for DFOL. The semantics is functorial in the
sense of Lawvere, and uses a dependent version of the Lindenbaum-Tarski algebra
for a DFOL theory. Agreement with standard first-order semantics is
established. Applications of DFOL to constructive mathematics and categorical
foundations are given. A key feature is a local propositions-as-types
principle.Comment: 83 page
Kripke Semantics for Martin-L\"of's Extensional Type Theory
It is well-known that simple type theory is complete with respect to
non-standard set-valued models. Completeness for standard models only holds
with respect to certain extended classes of models, e.g., the class of
cartesian closed categories. Similarly, dependent type theory is complete for
locally cartesian closed categories. However, it is usually difficult to
establish the coherence of interpretations of dependent type theory, i.e., to
show that the interpretations of equal expressions are indeed equal. Several
classes of models have been used to remedy this problem. We contribute to this
investigation by giving a semantics that is standard, coherent, and
sufficiently general for completeness while remaining relatively easy to
compute with. Our models interpret types of Martin-L\"of's extensional
dependent type theory as sets indexed over posets or, equivalently, as
fibrations over posets. This semantics can be seen as a generalization to
dependent type theory of the interpretation of intuitionistic first-order logic
in Kripke models. This yields a simple coherent model theory, with respect to
which simple and dependent type theory are sound and complete
A Declarative Foundation of λProlog with Equality
We build general model-theoretic semantics for higher-order logic programming languages. Usual semantics for first-order logic is two-level: i.e., at a lower level we define a domain of individuals, and then, we define satisfaction of formulas with respect to this domain. In a higher-order logic which includes the propositional type in its primitive set of types, the definition of satisfaction of formulas is mutually recursive with the process of evaluation of terms. As result of this in higher-order logic it is extremely difficult to define an effective semantics. For example to define T p operator for logic program P, we need a fixed domain without regard to interpretations. In usual semantics for higher-order logic, domain is dependent on interpretations. We overcome this problem and argue that our semantics provides a more suitable declarative basis for higher-order logic programming than the usual general model semantics. We develop a fix point semantics based on our model. We also show that a quotient of the domain of our model can be the domain of a model for higher-order logic programs with equality
A Semantics of ? into Dedukti
? is a semantical framework for formally describing the semantics of programming languages thanks to a BNF grammar and rewriting rules on configurations. It is also an environment that offers various tools to help programming with the languages specified in the formalism. For example, it is possible to execute programs thanks to the generated interpreter, or to check their properties thanks to the provided automatic theorem prover called the KProver. ? is based on la Matching Logic, a first-order logic with an application and fixed-point operators, extended with symbols to encode equality, typing and rewriting. This specific la Matching Logic theory is called Kore.
Dedukti is a logical framework having for main goal the interoperability of proofs between different formal proof tools. Several translators to Dedukti exist or are under development, in order to automatically translate formalizations written, for instance, in Coq or PVS. Dedukti is based on the ??-calculus modulo theory, a ?-calculus with dependent types and extended with a primitive notion of computation defined by rewriting rules. The flexibility of this logical framework allows to encode many theories ranging from first-order logic to the Calculus of Constructions.
In this article, we present a paper formalization of the translation from ? into Kore, and a paper formalization and an automatic translation tool, called KaMeLo, from Kore to Dedukti in order to execute programs in Dedukti
Using Histories to Implement Atomic Objects
In this paper we describe an approach of implementing atomicity. Atomicity requires that computations appear to be all-or-nothing and executed in a serialization order. The approach we describe has three characteristics. First, it utilizes the semantics of an application to improve concurrency. Second, it reduces the complexity of application-dependent synchronization code by analyzing the process of writing it. In fact, the process can be automated with logic programming. Third, our approach hides the protocol used to arrive at a serialization order from the applications. As a result, different protocols can be used without affecting the applications. Our approach uses a history tree abstraction. The history tree captures the ordering relationship among concurrent computations. By determining what types of computations exist in the history tree and their parameters, a computation can determine whether it can proceed
Reasoning about functional programs by combining interactive and automatic proofs
We propose a new approach to computer-assisted verification of lazy
functional programs where functions can be defined by general
recursion. We work in first-order theories of functional programs
which are obtained by translating Dybjer's programming logic
(Dybjer, P. [1985]. Program Verification in a Logical Theory of
Constructions. In: Functional Programming Languages and Computer
Architecture. Ed. by Jouannaud, J. P. Vol. 201. Lecture Notes in
Computer Science. Springer, pp. 334–349) into a first-order theory,
and by extending this programming logic with new (co-)inductive
predicates. Rather than building a special purpose system, we
formalise our theories in Agda, a proof assistant for dependent type
theory which can be used as a generic theorem prover. Agda provides
support for interactive reasoning by representing first-order theories
using the propositions-as-types principle. Further support is provided
by off-the-shelf automatic theorem provers for first-order-logic
called by a Haskell program that translates our Agda representations
of first-order formulae into the TPTP language understood by the
provers. We show some examples where we combine interactive and
automatic reasoning, covering both proofs by induction and
co-induction. The examples include functions defined by structural
recursion, simple general recursion, nested recursion, higher-order
recursion, guarded and unguarded co-recursion.Proponemos un nuevo enfoque a la verificación asistida por computador de programas funcionales perezosos, en los cuales las funciones pueden ser definidas por recursión general. Empleamos teorías de primer orden para programas funcionales las cuales fueron obtenidas de traducir la lógica para la programación de Dybjer (Dybjer, P. [1985]. Program Verification in a Logical Theory of Constructions. En: Functional Programming Languages and Computer Architecture. Ed. by Jouannaud,
J.-P. Vol. 201. Lecture Notes in Computer Science. Springer,
págs. 334–349) a una teoría de primer orden, y de extender esta lógica para la programación con nuevos predicados (co-)inductivos. En lugar de construir un sistema para formalizar nuestras teorías, formalizamos éstas en Agda, un asistente de pruebas para teoría de tipos dependientes que puede ser usado como un demostrador de teoremas genérico. Agda proporciona soporte para el razonamiento interactivo representando las teorías de primer orden mediante el principio de propositions-as-types. Se obtiene soporte adicional mediante demostradores automáticos de teoremas genéricos para lógica de primer orden, los cuales son llamados por un programa desarrollado en Haskell, que traslada nuestra representación en Agda de las fórmulas de primer orden al lenguaje TPTP entendido por los demostradores automáticos. Mostramos ejemplos de combinación de razonamiento interactivo y automático en pruebas por inducción y por co-inducción. Nuestros ejemplos incluyen funciones definidas por recursión estructural, recursión general simple, recursión anidada, recursión de orden superior y co-recursión
Margrave: An Improved Analyzer for Access-Control and Configuration Policies
As our society grows more dependent on digital systems, policies that regulate access to electronic resources are becoming more common. However, such policies are notoriously difficult to configure properly, even for trained professionals. An incorrectly written access-control policy can result in inconvenience, financial damage, or even physical danger. The difficulty is more pronounced when multiple types of policy interact with each other, such as in routers on a network. This thesis presents a policy-analysis tool called Margrave. Given a query about a set of policies, Margrave returns a complete collection of scenarios that satisfy the query. Since the query language allows multiple policies to be compared, Margrave can be used to obtain an exhaustive list of the consequences of a seemingly innocent policy change. This feature gives policy authors the benefits of formal analysis without requiring that they state any formal properties about their policies. Our query language is equivalent to order-sorted first-order logic (OSL). Therefore our scenario-finding approach is, in general, only complete up to a user-provided bound on scenario size. To mitigate this limitation, we identify a class of OSL that we call Order-Sorted Effectively Propositional Logic (OS-EPL). We give a linear-time algorithm for testing membership in OS-EPL. Sentences in this class have the Finite Model Property, and thus Margrave\u27s results on such queries are complete without user intervention
First steps in synthetic guarded domain theory: step-indexing in the topos of trees
We present the topos S of trees as a model of guarded recursion. We study the
internal dependently-typed higher-order logic of S and show that S models two
modal operators, on predicates and types, which serve as guards in recursive
definitions of terms, predicates, and types. In particular, we show how to
solve recursive type equations involving dependent types. We propose that the
internal logic of S provides the right setting for the synthetic construction
of abstract versions of step-indexed models of programming languages and
program logics. As an example, we show how to construct a model of a
programming language with higher-order store and recursive types entirely
inside the internal logic of S. Moreover, we give an axiomatic categorical
treatment of models of synthetic guarded domain theory and prove that, for any
complete Heyting algebra A with a well-founded basis, the topos of sheaves over
A forms a model of synthetic guarded domain theory, generalizing the results
for S
- …