24,689 research outputs found
A simple sequent calculus for nominal logic
Nominal logic is a variant of first-order logic that provides support for
reasoning about bound names in abstract syntax. A key feature of nominal logic
is the new-quantifier, which quantifies over fresh names (names not appearing
in any values considered so far). Previous attempts have been made to develop
convenient rules for reasoning with the new-quantifier, but we argue that none
of these attempts is completely satisfactory.
In this article we develop a new sequent calculus for nominal logic in which
the rules for the new- quantifier are much simpler than in previous attempts.
We also prove several structural and metatheoretic properties, including
cut-elimination, consistency, and equivalence to Pitts' axiomatization of
nominal logic
Semantics out of context: nominal absolute denotations for first-order logic and computation
Call a semantics for a language with variables absolute when variables map to
fixed entities in the denotation. That is, a semantics is absolute when the
denotation of a variable a is a copy of itself in the denotation. We give a
trio of lattice-based, sets-based, and algebraic absolute semantics to
first-order logic. Possibly open predicates are directly interpreted as lattice
elements / sets / algebra elements, subject to suitable interpretations of the
connectives and quantifiers. In particular, universal quantification "forall
a.phi" is interpreted using a new notion of "fresh-finite" limit and using a
novel dual to substitution.
The interest of this semantics is partly in the non-trivial and beautiful
technical details, which also offer certain advantages over existing
semantics---but also the fact that such semantics exist at all suggests a new
way of looking at variables and the foundations of logic and computation, which
may be well-suited to the demands of modern computer science
Nominal Logic Programming
Nominal logic is an extension of first-order logic which provides a simple
foundation for formalizing and reasoning about abstract syntax modulo
consistent renaming of bound names (that is, alpha-equivalence). This article
investigates logic programming based on nominal logic. We describe some typical
nominal logic programs, and develop the model-theoretic, proof-theoretic, and
operational semantics of such programs. Besides being of interest for ensuring
the correct behavior of implementations, these results provide a rigorous
foundation for techniques for analysis and reasoning about nominal logic
programs, as we illustrate via examples.Comment: 46 pages; 19 page appendix; 13 figures. Revised journal submission as
of July 23, 200
Formalising the pi-calculus using nominal logic
We formalise the pi-calculus using the nominal datatype package, based on
ideas from the nominal logic by Pitts et al., and demonstrate an implementation
in Isabelle/HOL. The purpose is to derive powerful induction rules for the
semantics in order to conduct machine checkable proofs, closely following the
intuitive arguments found in manual proofs. In this way we have covered many of
the standard theorems of bisimulation equivalence and congruence, both late and
early, and both strong and weak in a uniform manner. We thus provide one of the
most extensive formalisations of a process calculus ever done inside a theorem
prover.
A significant gain in our formulation is that agents are identified up to
alpha-equivalence, thereby greatly reducing the arguments about bound names.
This is a normal strategy for manual proofs about the pi-calculus, but that
kind of hand waving has previously been difficult to incorporate smoothly in an
interactive theorem prover. We show how the nominal logic formalism and its
support in Isabelle accomplishes this and thus significantly reduces the tedium
of conducting completely formal proofs. This improves on previous work using
weak higher order abstract syntax since we do not need extra assumptions to
filter out exotic terms and can keep all arguments within a familiar
first-order logic.Comment: 36 pages, 3 figure
Strongly Normalizing Audited Computation
Auditing is an increasingly important operation for computer programming, for example in security (e.g. to enable history-based access control) and to enable reproducibility and accountability (e.g. provenance in scientific programming). Most proposed auditing techniques are ad hoc or treat auditing as a second-class, extralinguistic operation; logical or semantic foundations for auditing are not yet well-established. Justification Logic (JL) offers one such foundation; Bavera and Bonelli introduced a computational interpretation of JL called lambda^h that supports auditing. However, lambda^h is technically complex and strong normalization was only established for special cases. In addition, we show that the equational theory of lambda^h is inconsistent. We introduce a new calculus lambda^hc that is simpler than lambda^hc, consistent, and strongly normalizing. Our proof of strong normalization is formalized in Nominal Isabelle
Nominal Abstraction
Recursive relational specifications are commonly used to describe the
computational structure of formal systems. Recent research in proof theory has
identified two features that facilitate direct, logic-based reasoning about
such descriptions: the interpretation of atomic judgments through recursive
definitions and an encoding of binding constructs via generic judgments.
However, logics encompassing these two features do not currently allow for the
definition of relations that embody dynamic aspects related to binding, a
capability needed in many reasoning tasks. We propose a new relation between
terms called nominal abstraction as a means for overcoming this deficiency. We
incorporate nominal abstraction into a rich logic also including definitions,
generic quantification, induction, and co-induction that we then prove to be
consistent. We present examples to show that this logic can provide elegant
treatments of binding contexts that appear in many proofs, such as those
establishing properties of typing calculi and of arbitrarily cascading
substitutions that play a role in reducibility arguments.Comment: To appear in the Journal of Information and Computatio
Finite and infinite support in nominal algebra and logic: nominal completeness theorems for free
By operations on models we show how to relate completeness with respect to
permissive-nominal models to completeness with respect to nominal models with
finite support. Models with finite support are a special case of
permissive-nominal models, so the construction hinges on generating from an
instance of the latter, some instance of the former in which sufficiently many
inequalities are preserved between elements. We do this using an infinite
generalisation of nominal atoms-abstraction.
The results are of interest in their own right, but also, we factor the
mathematics so as to maximise the chances that it could be used off-the-shelf
for other nominal reasoning systems too. Models with infinite support can be
easier to work with, so it is useful to have a semi-automatic theorem to
transfer results from classes of infinitely-supported nominal models to the
more restricted class of models with finite support.
In conclusion, we consider different permissive-nominal syntaxes and nominal
models and discuss how they relate to the results proved here
- …