Search

This paper presents a method to evaluate untyped lambda terms based on a term tree-traversing technique and judicious use of eta-expansion. The traversal method is inspired by Game Semantics. As traversals explore nodes of the term tree, they dynamically eta-expand some of the subterms to locate their non-immediate arguments. A quantity called dynamic arity determines the necessary amount of eta-expansion to perform at a given point. Traversals are finitely enumerable and characterize the paths in the tree representation of the beta-normal form when it exists. Correctness of the evaluation method follows from the fact that traversals implement leftmost linear reduction, a non-standard reduction strategy based on head linear reduction.

We are proposing a method for identifying whether the observed behaviour of a function at an interface is consistent with the typical behaviour of a particular programming language. This is a challenging problem with significant potential applications such as in security (intrusion detection) or compiler optimisation (profiling). To represent behaviour we use game semantics, a powerful method of semantic analysis for programming languages. It gives mathematically accurate models (‘fully abstract’) for a wide variety of programming languages. Game-semantic models are combinatorial characterisations of all possible interactions between a term and its syntactic context. Because such interactions can be concretely represented as sets of sequences, it is possible to ask whether they can be learned from examples. Concretely, we are using LSTM, a technique which proved effective in learning natural languages for automatic translation and text synthesis, to learn game-semantic models of sequential and concurrent versions of Idealised Algol (IA), which are algorithmically complex yet can be concisely described. We will measure how accurate the learned models are as a function of the degree of the term and the number of free variables involved. Finally, we will show how to use the learned model to perform latent semantic analysis between concurrent and sequential Idealised Algol.

Many software systems are today built as program families. They permit users to derive a custom program (variant) by selecting suitable configuration options at compile time according to their requirements. Many such program families are safety critical. However, most existing verification techniques are designed to work on the level of single programs. Their application to program families would require to verify each variant in isolation, in a brute force fashion. This approach does not scale in practice due to the (potentially) huge number of possible variants. In this paper, we propose an efficient game semantics based approach for verification of open program families, i.e. program families with undefined components (identifiers). We use symbolic representation of algorithmic game semantics, where symbolic values for inputs are used instead of concrete ones. In this way, we can compactly represent program families with infinite integers as so-called (finite state) featured symbolic automata. Specifically designed model checking algorithms are then employed to uniformly verify safety of all programs (variants) from a family at once using a single compact model and to pinpoint those programs that are unsafe (respectively, safe). We present a prototype tool implementing this approach, and we illustrate its practicality with several examples.

Intensional logic programming is an extension of logic programming based on intensional logic, which includes as special cases both temporal and modal logic programming. In [13] , M. Orgun and W.W. Wadge provided a general framework for capturing the semantics of intensional logic programming languages. They demonstrated that if the intensional operators of a language obey some simple semantic properties, then the programs of the language are guaranteed to have a minimum model semantics. One key property involved in the construction of [13] is the monotonicity of intensional operators. In this paper we consider intensional logic programming from a game-theoretic perspective. In particular we define a two-person game and demonstrate that it can be used in order to define a model for any given intensional program of the class introduced in [13] . Moreover, this model is shown to be identical to the minimum model constructed in [13] . More importantly, we demonstrate that the game is even applicable to intensional languages with non-monotonic operators. In this way we provide the first (to our knowledge) general framework for capturing the semantics of non-monotonic intensional logic programming.

Computational effects which provide access to the flow of control (such as first-class continuations, exceptions and delimited continuations) are important features of higher-order programming languages. There are fundamental differences between them in terms of operational behaviour, expressiveness and implementation, so that understanding how they combine and relate to each other is a challenging objective, with a key role for semantics in making this precise. This paper develops operational and denotational semantics for a hierarchy of programming languages which include combinations of locally declared control prompts to which a program can escape, with first-class continuations which may either capture their enclosing prompts, or be delimited by them. We describe two different hierarchies of models, both based on categories of games and strategies with a computational monad, but obtained using different methodologies. By relaxing combinations of behavioural constraints on strategies with control flow represented by annotation with control pointers we are able to give direct and explicit characterizations of control operators and their effects, including examples characterizing their macro-expressiveness. By constructing a parallel hierarchy of models by applying sequences of monad transformers, and relating these to the direct interpretation of control effects, we obtain games interpretations of higher-level abstractions such as continuations and exceptions, which can be used as the basis for equational reasoning about programs.

In Osorio et al. [Revisiting Z. Notre Dame Journal of Formal Logic, 55(1):129–155, 2014] introduced a paraconsistent three-valued logic, the logic CG 3 ′ which was named after the logic G 3 ′ due to the close relation between them. Authors defined CG 3 ′ via the three-valued matrix that defines G 3 ′ but changing the set of designated truth values. In this article we present a brief study of the Kripke-type semantics for some logics related with CG 3 ′ before constructing a Kripke-type semantics for it.

We define a new logic programming semantics in terms of abducible atoms. We use it to characterize the stage extensions of an argumentation framework AF by means of an associated normal program PAF. We also define the stage semantics for a special type of normal programs and present a similar characterization.

We define and study a slight variation on the semantics of Strategy Logic: while in the classical semantics, all strategies are shifted during the evaluation of temporal modalities, we propose to only shift the strategies that have been assigned to a player, thus matching the intuition that we can assign the very same strategy to the players at different points in time. We prove that surprisingly, this renders the model-checking problem undecidable. Strategy logic is a powerful formalism for expressing properties of multi-player games;We propose a (natural) variant of the semantics of Strategy Logic;While the change may look minor, we prove that the model-checking problem becomes undecidable.

We present a model of concurrent games in which strategies are probabilistic and support both discrete and continuous distributions. This is a generalisation of the probabilistic concurrent strategies of Winskel, based on event structures. We first introduce measurable event structures, discrete fibrations of event structures in which each fibre is turned into a measurable space. We then construct a bicategory of measurable games and measurable strategies based on measurable event structures, and add probability to measurable strategies using standard techniques of measure theory. We illustrate the model by giving semantics to an affine, higher-order, probabilistic language with a type of real numbers and continuous distributions.

Relational semantics, given by Kripke frames, play an essential role in the study of modal and intuitionistic logic. In [4] it is shown that the theory of relational semantics is also available in the more general setting of substructural logic, at least in an algebraic guise. Building on these ideas, in [5] a type of frames is described which generalise Kripke frames and provide semantics for substructural logics in a purely relational form. In this paper we study full linear logic from an algebraic point of view. The main additional hurdle is the exponential. We analyse this operation algebraically and use canonical extensions to obtain relational semantics. Thus, we extend the work in [4] , [5] and use their approach to obtain relational semantics for full linear logic. Hereby we illustrate the strength of using canonical extension to retrieve relational semantics: it allows a modular and uniform treatment of additional operations and axioms. Traditionally, so-called phase semantics are used as models for (provability in) linear logic [8] . These have the drawback that, contrary to our approach, they do not allow a modular treatment of additional axioms. However, the two approaches are related, as we will explain.

Many real-time game world servers run on stand-alone PCs, such that user performance is bound to fairly modest hardware configurations. Studies of multicore architectures to optimize such servers are sparse, and evaluations typically involve the use of one or two arbitrary performance metrics. However, the behavior of game servers is complex and the interpretation of metrics, particularly in the case of parallel implementations, is not straightforward. Our initial interest is in efficient load-balancing of multicore game engines. However, the focus of this paper is on performance metrics: starting with proposed metrics from other works, we investigate their effectiveness and inter-relationships, propose new variants, and discuss how they can be used in combination to gain a better understanding of actual performance. The use of metrics to inform the design and optimization of game software has gained recent interest from academics and practitioners alike: we conclude to show, by example, how server metrics can be directly connected with game semantics, and used to predict the impact of game design changes on server performance.

The present paper constructs three new systems of clarithmetic (arithmetic based on computability logic): CLA8, CLA9 and CLA10. System CLA8 is shown to be sound and extensionally complete with respect to PA-provably recursive time computability. This is in the sense that an arithmetical problem A has a τ-time solution for some PA-provably recursive function τ iff A is represented by some theorem of CLA8. System CLA9 is shown to be sound and intensionally complete with respect to constructively PA-provable computability. This is in the sense that a sentence X is a theorem of CLA9 iff, for some particular machine M , PA proves that M computes (the problem represented by) X. And system CLA10 is shown to be sound and intensionally complete with respect to not-necessarily-constructively PA-provable computability. This means that a sentence X is a theorem of CLA10 iff PA proves that X is computable, even if PA does not “know” of any particular machine M that computes X.

The paper considers an extension of concurrent games with a payoff, i.e. a numerical value resulting from the interaction of two players. We extend a recent determinacy result on concurrent games [Pierre Clairambault, Julian Gutierrez, and Glynn Winskel. The winning ways of concurrent games. In LICS. IEEE Computer Society, 2012] to a value theorem, i.e. a value that both players can get arbitrarily close to, whatever the behaviour of their opponent. This value is not reached in general, i.e. there is not always an optimal strategy for one of the players (there is for finite games). However when they exist, we show that optimal strategies are closed under composition, which opens up the possibility of computing optimal strategies for complex games compositionally from optimal strategies for their component games.

We prove a soundness and completeness result for Aschieri and Berardiʼs learning based realizability for Heyting Arithmetic plus Excluded Middle over semi-decidable statements with respect to 1-Backtracking Coquand game semantics. First, we prove that learning based realizability is sound with respect to 1-Backtracking Coquand game semantics. In particular, any realizer of an implication-and-negation-free arithmetical formula embodies a winning recursive strategy for the 1-Backtracking version of Tarski games. We also give examples of realizers and winning strategy extraction for some classical proofs. Secondly, we extend our notion of realizability to a total recursive learning based realizability and show that the notion is complete with respect to 1-Backtracking Coquand game semantics.

This paper introduces a new simplified version of the countable branching recurrence of Computability Logic, proves its equivalence to the old one, and shows that the basic logic induced by it is a proper superset of the basic logic induced by the uncountable branching recurrence. A further result of this paper is showing that the countable branching recurrence is strictly weaker than the uncountable branching recurrence in the sense that the latter logically implies the former but not vice versa., 20 pages

This letter introduces a new, substantially simplified version of the branching recurrence operation of computability logic (see http://www.cis.upenn.edu/~giorgi/cl.html), and proves its equivalence to the old, "canonical" version.

Game semantics is a trace-like denotational semantics for programming languages where the notion of legal observable behaviour of a term is defined combinatorially, by means of rules of a game between the term (the Proponent) and its context (the Opponent). In general, the richer the computational features a language has the less constrained the rules of the semantic game. In this paper we consider the consequences of taking this relaxation of rules to the limit, by granting the Opponent omnipotence, that is, permission to play any move without combinatorial restrictions. However, we impose an epistemic restriction by not granting Opponent omniscience, so that Proponent can have undisclosed secret moves. We introduce a basic C-like programming language and we define such a semantic model for it. We argue that the resulting semantics is an appealingly simple combination of operational and game semantics and we show how certain traces explain system-level attacks, i.e. plausible attacks that are realisable outside of the programming language itself. We also show how allowing Proponent to have secrets ensures that some desirable equivalences in the programming language are preserved.

We examine different approaches to reasoning about program equivalence in a higher-order language which incorporates a basic notion of state: references of unit type (names). In particular, we present three such methods stemming from logical relations, bisimulation techniques and game semantics respectively. The methods are tested against a surprisingly difficult example equivalence at second order which exploits the intricacies of the language with respect to privacy and flow of names, and the ensuing notion of local state.

This paper shows that, even at the most basic level (namely, in combination with only ¬ , ∧ , ∨ ), the parallel, countable branching and uncountable branching recurrences of computability logic validate different principles.

We present the RFuzzy framework, a Prolog-based tool for representing and reasoning with fuzzy information. The advantages of our framework in comparison to previous tools along this line of research are its easy, user-friendly syntax, and its expressivity through the availability of default values and types. In this approach we describe the formal syntax, the operational semantics and the declarative semantics of RFuzzy (based on a lattice). A least model semantics, a least fixpoint semantics and an operational semantics are introduced and their equivalence is proven. We provide a real implementation that is free and available. (It can be downloaded from http://babel.ls.fi.upm.es/software/rfuzzy/.) Besides implementation details, we also discuss some actual applications using RFuzzy.

We obtain a simple, purely game-theoretic characterization of Boolean grammars [A. Okhotin, Boolean grammars, Information and Computation, 194(1) (2004) 19-481. In particular, we propose a two-player infinite game of perfect information for Boolean grammars, which is equivalent to their well-founded semantics. The game is directly applicable to the simpler classes of conjunctive and context-free grammars, and offers a promising new connection between game theory and formal languages. (C) 2010 Elsevier B.V. All rights reserved. Theoretical Computer Science

This paper presents a game semantics for a simply-typed λ-calculus with qbits constants and associated quantum operations. The resulting language is expressive enough to encode any quantum circuit. The language uses a notion of extended variable, similar to that seen in functional languages with pattern matching, but adapted to the needs of dealing with tensor products. The game semantics is constructed from classical game semantics using quantum interventions as questions and measurements results as answers. A soundness result for the semantics is given.

Game Semantics has successfully provided fully abstract models for a variety of programming languages not possible using other denotational approaches. Although it is a flexible and accurate way to give semantics to a language, its underlying mathematics is awkward. For example, the proofs that strategies compose associatively and maintain properties imposed on them such as innocence are intricate and require a lot of attention. This work aims at beginning to provide a more elegant and uniform mathematical ground for Game Semantics. Our quest is to find mathematical entities that will retain the properties that make games an accurate way to give semantics to programs, yet that are simple and familiar to work with. Our main result is a full, faithful strong monoidal embedding of a category of games into a category of coherence spaces, where composition is simple composition of relations.

Using game semantics, we prove a full abstraction result (with respect to the may-testing preorder) for Idealized Algol augmented with parallel composition (IA||). Although it is common knowledge that semaphores can be implemented using shared memory, we find that semaphores do not extend IA|| conservatively. We explain the reasons for the mismatch.

This paper extends previous work on the compilation of higher-order imperative languages into digital circuits [Ghica, D.R., Geometry of Synthesis: a structured approach to VLSI design, in: POPL, 2007, pp. 363–375.]. We introduce concurrency, an essential feature in the context of hardware compilation and we re-use an existing game model to simplify correctness proofs. The target designs we compile to are asynchronous event-logic circuits, which naturally match the asynchronous game model of the language.

We show that the uniform validity is equivalent to the non-uniform validity for Blass' semantics of [A. Blass, A game semantics for linear logic, Ann. Pure Appl. Logic 56 (1992) 183–220]. We present a shorter proof (than that of [G. Japaridze, The intuitionistic fragment of computability logic at the propositional level, Ann. Pure Appl. Logic 147 (3) (2007) 187–227]) of the completeness of the positive fragment of intuitionistic logic for this semantics, computability logic semantics, and the abstract resource semantics.

Classical proof forests are a proof formalism for first-order classical logic based on Herbrand’s Theorem and backtracking games in the style of Coquand. First described by Miller in a cut-free setting as an economical representation of first-order and higher-order classical proof, defining features of the forests are a strict focus on witnessing terms for quantifiers and the absence of inessential structure, or ‘bureaucracy’. This paper presents classical proof forests as a graphical proof formalism and investigates the possibility of composing forests by cut-elimination. Cut-reduction steps take the form of a local rewrite relation that arises from the structure of the forests in a natural way. Yet reductions, which are significantly different from those of the sequent calculus, are combinatorially intricate and do not exclude the possibility of infinite reduction traces, of which an example is given. Cut-elimination, in the form of a weak normalisation theorem, is obtained using a modified version of the rewrite relation inspired by the game-theoretic interpretation of the forests. It is conjectured that the modified reduction relation is, in fact, strongly normalising.

We associate with any game G another game, which is a variant of it, and which we call bck(G). Winning strategies for bck(G) have a lower recursive degree than winning strategies for G: if a player has a winning strategy of recursive degree 1 over G, then it has a recursive winning strategy over bck(G), and vice versa. Through bck(G) we can express in algorithmic form, as a recursive winning strategy, many (but not all) common proofs of non-constructive Mathematics, namely exactly the theorems of the sub-classical logic Limit Computable Mathematics (Hayashi (2006) [6], Hayashi and Nakata (2001) [7]). (C) 2010 Elsevier B.V. All rights reserved.

We study the notion of strong equivalence between two disjunctive logic programs under the G 3 ′ -stable model semantics, also called the p-stable semantics, and we show how some particular cases of testing strong equivalence between programs can be reduced to checking whether a formula is a theorem in some paraconsistent logic, or in some cases in classical logic. We also present some program transformations for disjunctive programs which can be used to reduce the size of a program.

International audience; We tackle the problem of preservation of totality by composition in arena games. We first explain how this problem reduces to a finiteness theorem on what we call pointer structures, similar to the parity pointer functions of Harmer, Hyland and Mélliès and the interaction sequences of Coquand. We discuss how this theorem relates to normalization of linear head reduction in simply-typed lambda-calculus, leading us to a semantic realizability proof à la Kleene of our theorem. We then present another proof of a more combinatorial nature. Finally, we discuss the exact class of strategies to which our theorems apply.

The description of resources in game semantics has never achieved the simplicity and precision of linear logic, because of the misleading conception that linear logic is more primitive than game semantics. Here, we defend the opposite view, and thus advocate that game semantics is conceptually more primitive than linear logic. This revised point of view leads us to introduce tensor logic, a primitive variant of linear logic where negation is not involutive. After formulating its categorical semantics, we interpret tensor logic in a model based on Conway games equipped with a notion of payoff, in order to reflect the various resource policies of the logic: linear, affine, relevant or exponential.

We present a setting in which the search for a proof of B or a refutation of B (i.e., a proof of ¬B) can be carried out simultaneously: in contrast, the usual approach in automated deduction views proving B or proving ¬B as two, possibly unrelated, activities. Our approach to proof and refutation is described as a two-player game in which each player follows the same rules. A winning strategy translates to a proof of the formula and a counter-winning strategy translates to a refutation of the formula. The game is described for multiplicative and additive linear logic (MALL). A game theoretic treatment of the multiplicative connectives is intricate and our approach to it involves two important ingredients. First, labeled graph structures are used to represent positions in a game and, second, the game playing must deal with the failure of a given player and with an appropriate resumption of play. This latter ingredient accounts for the fact that neither player might win (that is, neither B nor ¬B might be provable).

The paper provides an overview of the s-semantic approach to the semantics of logic programs which had been developed about twenty years ago. The aim of such an approach was that of providing a suitable base for program analysis by means of a semantics which really captures the operational behavior of logic programs, and thus offers useful notions of observable program equivalences. The semantics is given in terms of extended interpretations, which are more expressive than Herbrand interpretations, extends the standard Herbrand semantics, and can be obtained as a result of both top-down and bottom-up constructions. The approach has been applied to several extensions of positive logic programs and used to develop semantic-based techniques for program analysis, verification and transformation.

We introduce a semantic approach to the study of logics for access control and dependency analysis, based on Game Semantics. We use a variant of AJM games with explicit justification (but without pointers). Based on this, we give a simple and intuitive model of the information flow constraints underlying access control. This is used to give strikingly simple proofs of \emph{non-interference theorems} in robust, semantic versions., Comment: 21 pages

In the standard sequent presentations of Girard's Linear Logic (LL), there are two "non-decreasing" rules, where the premises are not smaller than the conclusion, namely the cut and the contraction rules. It is a universal concern to eliminate the cut rule. We show that, using an admissible modification of the tensor rule, contractions can be eliminated, and that cuts can be simultaneously limited to a single initial occurrence. This view leads to a consistent, but incomplete game model for LL with exponentials, which is finitary, in the sense that each play is finite. The game is based on a set of inference rules which does not enjoy cut elimination. Nevertheless, the cut rule is valid in the model., 19 pages, uses tikz and Paul Taylor's diagrams

We consider a simple and well-known category of alternating games (also known as sequential data structures) and several categories derived from it. In each case, we present an extension of Plotkin's language FPC (or a suitable linearization thereof) which defines all computable strategies of appropriate types. The quest for such languages results in a novel selection of language primitives for state encapsulation, coroutining and backtracking.

International audience; We study the algebraic structure of a programming language with higher-order store, in the style of ML references. Instead of working directly on the operational semantics of the language, we consider its fully abstract game semantics defined by Abramsky, Honda and McCusker one decade ago. This alternative description of the language is nice and conceptual, except on one significant point: the interactive behavior of the higher-order memory cell is reflected in the model by a strategy $\mathtt{cell}$ whose definition remains slightly enigmatic. The purpose of our work is precisely to clarify this point, by providing a neat algebraic definition of the strategy. This conceptual reconstruction of the memory cell is based on the idea that a general reference behaves essentially as a linear feedback (or trace operator) in an ambient category of Conway games and strategies. This analysis leads to a purely axiomatic proof of soundness of the model, based on a natural refinement of the replication modality of tensor logic.

Computability logic (CL) (see http://www.cis.upenn.edu/~giorgi/cl.html) is a semantical platform and research program for redeveloping logic as a formal theory of computability, as opposed to the formal theory of truth which it has more traditionally been. Formulas in CL stand for (interactive) computational problems, understood as games between a machine and its environment; logical operators represent operations on such entities; and "truth" is understood as existence of an effective solution, i.e., of an algorithmic winning strategy. The formalism of CL is open-ended, and may undergo series of extensions as the study of the subject advances. The main groups of operators on which CL has been focused so far are the parallel, choice, branching, and blind operators. The present paper introduces a new important group of operators, called sequential. The latter come in the form of sequential conjunction and disjunction, sequential quantifiers, and sequential recurrences. As the name may suggest, the algorithmic intuitions associated with this group are those of sequential computations, as opposed to the intuitions of parallel computations associated with the parallel group of operations: playing a sequential combination of games means playing its components in a sequential fashion, one after one. The main technical result of the present paper is a sound and complete axiomatization of the propositional fragment of computability logic whose vocabulary, together with negation, includes all three -- parallel, choice and sequential -- sorts of conjunction and disjunction. An extension of this result to the first-order level is also outlined., To appear in "Information and Computation"

Reynolds' view of a storage cell as an expression-acceptor pair has been widely used by researchers. We present a different way of organizing semantics of state, and in particular game semantics, by adding to typing contexts a zone for global state. This has the following advantages. Firstly, it causes the “good variable” equations for references to be validated, and also the noninterference equations between distinct references, as enumerated by Plotkin and Power. Secondly, it gives a cleaner categorical structure based on the configurations (state + program) used to describe operational semantics. Thirdly, it leads to a simpler proof that the game semantics is sound and adequate with respect to the operational semantics.

In this paper we present a game semantics for a quantum programming language based on a new definition of quantum strategies. The language studied is MCdata, a typed version of the measurement calculus recently introduced by Danos et. al. We give a soundness and adequacy result based on our quantum game semantics. The main contribution is not the semantics of MCdata but rather the development of ideas suitable for a game theoretic treatment of quantum computation in general.

We introduce an implication-free fragment PA inf + - Exch of ω -arithmetic, having Exchange rule for sequents dropped. Exchange rule for formulas is, instead, an admissible rule in PA inf + - Exch . Our main result is that cut-free proofs of PA inf + - Exch are isomorphic with recursive winning strategies of a set of games called “1-backtracking games” in [S. Berardi, Th. Coquand, S. Hayashi, Games with 1-backtracking, Games for Logic and Programming Languages, Edinburgh, April 2005]. We also show that PA inf + - Exch is a sound and complete formal system for the implication-free fragment of LCM (Limit Computable Mathematics, see [S. Hayashi, Mathematics based on Learning, Algorithmic Learning Theory, in: LNAI, vol. 2533, Springer, pp. 7–21; S. Hayashi, Can proofs be animated by games? in: P. Urzyczyn (Ed.), Seventh International Conference on Typed Lambda Calculi and Applications, in: Lecture Notes in Computer Science, vol. 3461, 2005, pp. 11–22. Invited paper]). A simple syntactical description of this fragment was still missing. No sound and complete formal system is known for LCM itself.

We investigate the decidability of observational equivalence and approximation in Reynolds' ''Syntactic Control of Interference'' (SCI), a prototypical functional-imperative language in which covert interference between functions and their arguments is prevented by the use of an affine typing discipline. By associating denotations of terms in a fully abstract ''relational'' model of finitary basic SCI (due to Reddy) with multitape finite state automata, we show that observational approximation is not decidable (even at first order), but that observational equivalence is decidable for all terms. We then consider the same problems for basic SCI extended with non-local control in the form of backwards jumps. We show that both observational approximation and observational equivalence are decidable in this ''observably sequential'' version of the language by describing a fully abstract games model in which strategies are regular languages.

We describe a fully abstract semantics for a simple functional language with locally declared names which may be used as pointers to names. It is based on a category of dialogue games acted upon by the group of natural number automorphisms. This allows a formal, semantic characterization of the key properties of names such as freshness and locality. We describe a model of the call-by-value λ -calculus (a closed Freyd category) based on these games, and show that it can be used to interpret the nu-calculus of Pitts and Stark. We then construct a model of our pointer-language by extending our category of games with an explicit representation of the store, using a notion of semantic garbage-collection to erase inaccessible pointers. Using factorization and decomposition techniques, we show that the compact elements of our model are definable as terms, and hence it is fully abstract.

We present an infinite-game characterization of the well-founded semantics for function-free logic programs with negation. Our game is a simple generalization of the standard game for negation-less logic programs introduced by van Emden [M.H. van Emden, Quantitative deduction and its fixpoint theory, Journal of Logic Programming 3 (1) (1986) 37–53] in which two players, the Believer and the Doubter , compete by trying to prove (respectively disprove) a query. The standard game is equivalent to the minimum Herbrand model semantics of logic programming in the sense that a query succeeds in the minimum model semantics iff the Believer has a winning strategy for the game which begins with the Doubter doubting this query. The game for programs with negation that we propose follows the same rules as the standard one, except that the players swap roles every time the play “passes through” negation. We start our investigation by establishing the determinacy of the new game by using some classical tools from the theory of infinite-games. Our determinacy result immediately provides a novel and purely game-theoretic characterization of the semantics of negation in logic programming. We proceed to establish the connections of the game semantics to the existing semantic approaches for logic programming with negation. For this purpose, we first define a refined version of the game that uses degrees of winning and losing for the two players. We then demonstrate that this refined game corresponds exactly to the infinite-valued minimum model semantics of negation [P. Rondogiannis,W.W. Wadge, Minimum model semantics for logic programs with negation-as-failure, ACM Transactions on Computational Logic 6 (2) (2005) 441–467]. This immediately implies that the unrefined game is equivalent to the well-founded semantics (since the infinite-valued semantics is a refinement of the well-founded semantics).

We solve a longstanding problem by providing a denotational model for nondeterministic programs that identifies two programs iff they have the same range of possible behaviours. We discuss the difficulties with traditional approaches, where divergence is bottom or where a term denotes a function from a set of environments. We see that making forcing explicit, in the manner of game semantics, allows us to avoid these problems. We begin by modelling a first-order language with sequential I/O and unbounded nondeterminism (no harder to model, using this method, than finite nondeterminism). Then we extend the model to a calculus with higher-order and recursive types, by adapting standard game semantics. Traditional adequacy proofs using logical relations are not applicable, so we use instead a novel hiding and unhiding argument.

We introduce a game model for a procedural programming language extended with primitives for parallel composition and synchronization on binary semaphores. The model uses an interleaved version of Hyland-Ong-style games, where most of the original combinatorial constraints on positions are replaced with a simple principle naturally related to static process creation. The model is fully abstract for may-equivalence.

This paper shows how rewriting logic semantics (RLS) can be used as a computational logic framework for operational semantic definitions of programming languages. Several operational semantics styles are addressed: big-step and small-step structural operational semantics (SOS), modular SOS, reduction semantics with evaluation contexts, and continuation-based semantics. Each of these language definitional styles can be faithfully captured as an RLS theory, in the sense that there is a one-to-one correspondence between computational steps in the original language definition and computational steps in the corresponding RLS theory. A major goal of this paper is to show that RLS does not force or pre-impose any given language definitional style, and that its flexibility and ease of use makes RLS an appealing framework for exploring new definitional styles.

This paper presents a soundness and completeness proof for propositional intuitionistic calculus with respect to the semantics of computability logic. The latter interprets formulas as interactive computational problems, formalized as games between a machine and its environment. Intuitionistic implication is understood as algorithmic reduction in the weakest possible -- and hence most natural -- sense, disjunction and conjunction as deterministic-choice combinations of problems (disjunction = machine's choice, conjunction = environment's choice), and "absurd" as a computational problem of universal strength. See http://www.cis.upenn.edu/~giorgi/cl.html for a comprehensive online source on computability logic.

We propose a semantics for the @?-quantifier of Miller and Tiu. First we consider the case for classical first-order logic. In this case, the interpretation is close to standard Tarski-semantics and completeness can be shown using a standard argument. Then we put our semantics into a broader context by giving a general interpretation of @? in categories with binding structure. Since categories with binding structure also encompass nominal logic, we thus show that both @?-logic and nominal logic can be modelled using the same definition of binding. As a special case of the general semantics in categories with binding structure, we recover Gabbay & Cheney's translation of [email protected]^@? into nominal logic.

20 pages; International audience; In this paper I present a game model for the semantical analysis of handshake circuits. I show how the model captures effectively the composition of circuits in an associative way. Then I build a compact-closed category of handshake games and handshake strategies. I then consider the language Tangram and I define a semantics for this language simply by giving a denotation in the model to each handshake component that is used in the compilation of Tangram programs.