Results 11  20
of
77
SOS formats and metatheory: 20 years after
, 2007
"... In 1981 Structural Operational Semantics (SOS) was introduced as a systematic way to define operational semantics of programming languages by a set of rules of a certain shape [G.D. Plotkin, A structural approach to operational semantics, Technical ..."
Abstract

Cited by 16 (6 self)
 Add to MetaCart
(Show Context)
In 1981 Structural Operational Semantics (SOS) was introduced as a systematic way to define operational semantics of programming languages by a set of rules of a certain shape [G.D. Plotkin, A structural approach to operational semantics, Technical
Mixing finite success and finite failure in an automated prover
 In Proceedings of ESHOL’05: Empirically Successful Automated Reasoning in HigherOrder Logics, pages 79 – 98
, 2005
"... Abstract. The operational semantics and typing judgements of modern programming and specification languages are often defined using relations and proof systems. In simple settings, logic programming languages can be used to provide rather direct and natural interpreters for such operational semantic ..."
Abstract

Cited by 15 (8 self)
 Add to MetaCart
Abstract. The operational semantics and typing judgements of modern programming and specification languages are often defined using relations and proof systems. In simple settings, logic programming languages can be used to provide rather direct and natural interpreters for such operational semantics. More complex features of specifications such as names and their bindings, proof rules with negative premises, and the exhaustive enumeration of state spaces, all pose significant challenges to conventional logic programming systems. In this paper, we describe a simple architecture for the implementation of deduction systems that allows a specification to interleave between finite success and finite failure. The implementation techniques for this prover are largely common ones from higherorder logic programming, i.e., logic variables, (higherorder pattern) unification, backtracking (using streambased computation), and abstract syntax based on simply typed λterms. We present a particular instance of this prover’s architecture and its prototype implementation, Level 0/1, based on the dual interpretation of (finite) success and finite failure in proof search. We show how Level 0/1 provides a highlevel and declarative implementation of model checking and bisimulation checking for the (finite) πcalculus. 1
Logical reasoning for higherorder functions with local state
 In Foundations of Software Science and Computation Structure
"... ABSTRACT. We introduce an extension of Hoare logic for callbyvalue higherorder functions with MLlike local reference generation. Local references may be generated dynamically and exported outside their scope, may store higherorder functions and may be used to construct complex mutable data stru ..."
Abstract

Cited by 15 (6 self)
 Add to MetaCart
(Show Context)
ABSTRACT. We introduce an extension of Hoare logic for callbyvalue higherorder functions with MLlike local reference generation. Local references may be generated dynamically and exported outside their scope, may store higherorder functions and may be used to construct complex mutable data structures. This primitive is captured logically using a predicate asserting reachability of a reference name from a possibly higherorder datum and quantifiers over hidden references. We explore the logic’s descriptive and reasoning power with nontrivial programming examples combining higherorder procedures and dynamically generated local state. Axioms for reachability and local invariant play a central role for reasoning about the examples.
Completeness and Logical Full Abstraction in Modal Logics for Typed Mobile Processes
"... Abstract. We study an extension of HennessyMilner logic for the πcalculus which gives a sound and complete characterisation of representative behavioural preorders and equivalences over typed processes. New connectives are introduced representing actual and hypothetical typed parallel composition ..."
Abstract

Cited by 15 (7 self)
 Add to MetaCart
(Show Context)
Abstract. We study an extension of HennessyMilner logic for the πcalculus which gives a sound and complete characterisation of representative behavioural preorders and equivalences over typed processes. New connectives are introduced representing actual and hypothetical typed parallel composition and hiding. We study three compositional proof systems, characterising the May/Must testing preorders and bisimilarity. The proof systems are uniformly applicable to different type disciplines. Logical axioms distill proof rules for parallel composition studied by Amadio and Dam. We demonstrate the expressiveness of our logic embeddings of program logics for higherorder functions. 1
Proof search specifications of bisimulation and modal logics for the πcalculus
 ACM Trans. on Computational Logic
"... We specify the operational semantics and bisimulation relations for the finite πcalculus within a logic that contains the ∇ quantifier for encoding generic judgments and definitions for encoding fixed points. Since we restrict to the finite case, the ability of the logic to unfold fixed points allo ..."
Abstract

Cited by 15 (9 self)
 Add to MetaCart
(Show Context)
We specify the operational semantics and bisimulation relations for the finite πcalculus within a logic that contains the ∇ quantifier for encoding generic judgments and definitions for encoding fixed points. Since we restrict to the finite case, the ability of the logic to unfold fixed points allows this logic to be complete for both the inductive nature of operational semantics and the coinductive nature of bisimulation. The ∇ quantifier helps with the delicate issues surrounding the scope of variables within πcalculus expressions and their executions (proofs). We shall illustrate several merits of the logical specifications permitted by this logic: they are natural and declarative; they contain no sideconditions concerning names of variables while maintaining a completely formal treatment of such variables; differences between late and open bisimulation relations arise from familar logic distinctions; the interplay between the three quantifiers (∀, ∃, and ∇) and their scopes can explain the differences between early and late bisimulation and between various modal operators based on bound input and output actions; and proof search involving the application of inference rules, unification, and backtracking can provide complete proof systems for onestep transitions, bisimulation, and satisfaction in modal logic. We also illustrate how one can encode the πcalculus with replications, in an extended logic with induction and coinduction.
Simple nominal type theory
"... Abstract. Nominal logic is an extension of firstorder logic with features useful for reasoning about abstract syntax with bound names. For computational applications such as programming and formal reasoning, it is desirable to develop constructive type theories for nominal logic which extend standa ..."
Abstract

Cited by 14 (2 self)
 Add to MetaCart
(Show Context)
Abstract. Nominal logic is an extension of firstorder logic with features useful for reasoning about abstract syntax with bound names. For computational applications such as programming and formal reasoning, it is desirable to develop constructive type theories for nominal logic which extend standard type theories for propositional, first or higherorder logic. This has proven difficult, largely because of complex interactions between nominal logic’s nameabstraction operation and ordinary functional abstraction. This difficulty already arises in the case of propositional logic and simple type theory. In this paper we show how this difficulty can be overcome, and present a simple nominal type theory which enjoys properties such as type soundness and strong normalization, and which can be soundly interpreted using existing nominal set models of nominal logic. We also sketch how recursion combinators for languages with binding structure can be provided. This is an important first step towards understanding the constructive content of nominal logic and incorporating it into existing logics and type theories. 1
Structural Recursion with Locally Scoped Names
"... This paper introduces a new recursion principle for inductively defined data modulo αequivalence of bound names that makes use of Oderskystyle local names when recursing over bound names. It is formulated in simply typed λcalculus extended with names that can be restricted to a lexical scope, tes ..."
Abstract

Cited by 13 (2 self)
 Add to MetaCart
This paper introduces a new recursion principle for inductively defined data modulo αequivalence of bound names that makes use of Oderskystyle local names when recursing over bound names. It is formulated in simply typed λcalculus extended with names that can be restricted to a lexical scope, tested for equality, explicitly swapped and abstracted. The new recursion principle is motivated by the nominal sets notion of “αstructural recursion”, whose use of names and associated freshness sideconditions in recursive definitions formalizes common practice with binders. The new calculus has a simple interpretation in nominal sets equipped with name restriction operations. It is shown to adequately represent αstructural recursion while avoiding the need to verify freshness sideconditions in definitions and computations. The paper is a revised and expanded version of (Pitts, 2010). 1
Nominal Abstraction
, 2009
"... 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, logicbased reasoning about such descriptions: the interpretation of atomic judgments through recursive ..."
Abstract

Cited by 11 (8 self)
 Add to MetaCart
(Show Context)
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, logicbased 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 coinduction 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.
Mechanized metatheory modelchecking
 In 9th International ACM SIGPLAN Symposium on Principles and Practice of Declarative Programming
, 2007
"... The problem of mechanically formalizing and proving metatheoretic properties of programming language calculi, type systems, operational semantics, and related formal systems has received considerable attention recently. However, the dual problem of searching for errors in such formalizations has rec ..."
Abstract

Cited by 10 (0 self)
 Add to MetaCart
(Show Context)
The problem of mechanically formalizing and proving metatheoretic properties of programming language calculi, type systems, operational semantics, and related formal systems has received considerable attention recently. However, the dual problem of searching for errors in such formalizations has received comparatively little attention. In this paper, we consider the problem of bounded modelchecking for metatheoretic properties of formal systems specified using nominal logic. In contrast to the current state of the art for metatheory verification, our approach is fully automatic, does not require expertise in theorem proving on the part of the user, and produces counterexamples in the case that a flaw is detected. We present two implementations of this technique, one based on negationasfailure and one based on negation elimination, along with experimental results showing that these techniques are fast enough to be used interactively to debug systems as they are developed.