Intensionality, Definability and Computation

TL;DR

This paper explores the concept of intensionality in computation through game semantics, highlighting its role in modeling programming languages and its potential for developing a mathematical theory of intensional structures.

Contribution

It reviews how game semantics characterizes sequential functional processes and discusses its potential for creating a formal theory of intensional structures.

Findings

Game semantics effectively models sequential functional processes.

It provides methods for constructing fully abstract models of programming languages.

Potential for developing a positive mathematical theory of intensional structures.

Abstract

We look at intensionality from the perspective of computation. In particular, we review how game semantics has been used to characterize the sequential functional processes, leading to powerful and flexible methods for constructing fully abstract models of programming languages, with applications in program analysis and verification. In a broader context, we can regard game semantics as a first step towards developing a positive theory of intensional structures with a robust mathematical structure, and finding the right notions of invariance for these structures.

Equations

$$x=y\leftrightarrow \forall z.z\in x\leftrightarrow z\in y.$$

$$f=g\leftrightarrow \forall x.f(x)=g(x).$$

$$f:A\to B$$

$$f(xy)=f(x)f(y),f(e)=e.$$

$$f:\mathbb{N}\rightharpoonup \mathbb{N}$$

$$f:\{0,1{\}}^{\ast }\text{rTo}\{0,1\}$$

$$s{\equiv }_{L}t\leftrightarrow \forall v\in A^{\ast }.sv\in L\leftrightarrow tv\in L.$$

$$\forall ,\exists :[\mathbb{N}\to \mathbb{B}]\to \mathbb{B}$$

$$\mathsf{let}m=P(n)\mathsf{in}\dots$$

$$\{m_1=P(n_1),m_2=P(n_2),\dots ,m_k=P(n_k)\}$$

$$f⊑g\leftrightarrow \mathsf{graph}(f)\subseteq \mathsf{graph}(g).$$

$$f_0⊑f_1⊑f_2⊑\cdots$$

$$\hat{F}(\underset{i}{⨆}{f}_i)=\underset{i}{⨆}\hat{F}(f_i).$$

$$x⊑y⟹f(x)⊑f(y).$$

$$f(\underset{n\in \omega }{⨆}{x}_n)=\underset{n\in \omega }{⨆}f(x_n).$$

$$f(\underset{n\in \omega }{⨆}{x}_n)⊑\underset{n\in \omega }{⨆}f(x_n)$$

$$\underset{n\in \omega }{⨆}f(x_n)⊑f(\underset{n\in \omega }{⨆}{x}_n)$$

$$\mathsf{lfp}(f)=\underset{n\in \omega }{⨆}{f}^n(\perp ).$$

$$\mathsf{por}:{\mathbb{B}}_{\perp }\to {\mathbb{B}}_{\perp }\to {\mathbb{B}}_{\perp }$$

$$\mathsf{por}\perp \mathbf{tt}=\mathbf{tt}=\mathsf{por}\mathbf{tt}\perp ,\mathsf{por}\mathbf{ff}\mathbf{ff}=\mathbf{ff}$$

$$\mathsf{lsor}(b_1,b_2)\equiv \mathsf{if}{b}_1\mathsf{then}\mathbf{tt}\mathsf{else}{b}_2$$

$$\mathsf{rsor}(b_1,b_2)\equiv \mathsf{if}{b}_2\mathsf{then}\mathbf{tt}\mathsf{else}{b}_1$$

$$\mathsf{lsor}(\mathbf{tt},\perp )=\mathbf{tt},\mathsf{lsor}(\perp ,\mathbf{tt})=\perp$$

$$\mathsf{rsor}(\mathbf{tt},\perp )=\perp ,\mathsf{rsor}(\perp ,\mathbf{tt})=\mathbf{tt}$$

$$\mathbb{N}=\{q\cdot n\mid n\in \mathbb{N}\}$$

$$f{t}_1{t}_2$$

Full text

Keywords

Computation, intentionality, extensionality, definability, game semantics.

0.1 Introduction

Our aim in this paper is to give a conceptual discussion of some issues concerning intensionality, definability and computation. Intensionality remains an elusive concept in logical theory, but actually becomes much more tangible and, indeed, inescapable in the context of computation. We will focus on a particular thread of ideas, leading to recent and ongoing work in game semantics. Technical details will be kept to a minimum, while ample references will be provided to the literature.

It is a pleasure and a privilege to contribute to a volume in honour of Johan van Benthem. Johan has been a friend and an inspiring and supportive colleague for well over a decade. He has encouraged me to broaden my intellectual horizons and to address wider conceptual issues. Although our technical languages and backgrounds are rather different, we have found a great deal of common ground in pursuing a broad and inclusive vision of logical dynamics. I look forward to continuing our interactions and discussions over the coming years.

0.1.1 Computability vs. Computer Science

Computability theory Rog (67); Cut (80) is concerned with the computability (or, most often, degree of non-computability) of extensional objects: numbers, sets, functions etc. These objects are inherited from mathematics and logic. To define when such objects are computable requires some additional structure: we say e.g. that a function is computable if there exists an algorithmic process for computing it. Hence the notion of computability relies on a characterization of algorithmic processes. This was, famously, what Turing achieved in his compelling analysis Tur (37).

Computer Science asks a broader question:

What is a process?

By contrast with the well-established extensional notions which provide the reference points for computability, there was no established mathematical theory of what processes are predating computer science.

0.1.2 Why processes matter in Computer Science

Let us pause to ask why Computer Science asks this broader question about the nature of informatic processes. The purpose of much of the software we routinely run is not to compute a function, but to exhibit some behaviour. Think of communication protocols, operating systems, browsers, iTunes, Facebook, Twitter, …. The purpose of these systems is not adequately described as the computation of some function.

Thus we are led ineluctably to questions such as:

What is a process? When are two processes equivalent?

The situation is very different to that which we find in computability theory, where we have

• •

A confluence of notions, whereby many different attempts to characterize the notion of algorithmic process have converged to yield the same class of computable functions Rog (67); Cut (80).

• •

A definitive calculus of functions: the $\lambda$-calculus Chu (41); Bar (84).

There has been active research on concurrency theory and processes for the past five decades in Computer Science Pet (66, 62); Mil (89, 99); Hoa (78). Many important concepts and results have emerged. However, one cannot help noticing that:

• •

Hundreds of different process calculi, equivalences, logics have been proposed.

• •

No $\lambda$-calculus for concurrency has emerged.

• •

There is no plausible Church-Turing thesis for processes.

This has been referred to as the ‘next 700’ syndrome, after Peter Landin’s paper (from 1966!) on ‘The Next 700 Programming Languages’ Lan (66); for a discussion of this syndrome, see Abr (06). Finding an adequate characterization of informatic processes in general can plausibly be considered to be a much harder problem than that of characterizing the notion of computable set or function. Despite the great achievements of Petri, Milner, Hoare, et al., we still await our modern-day Turing to provide a definitive analysis of this notion.

0.1.3 Prospectus

Our aim in this paper is to tell one limited but encouraging success story: the characterization of sequential functional processes using game semantics, solving in best possible terms the ‘full abstraction problem’ for PCF Mil (77); Plo (77). This has led on to many further developments, notably :

• •

Full abstraction and full completeness results for a wide range of programming languages, type theories and logics AJ (94); AJM (00); HO (00); AM (97); AM99a ; AHM (98); AM99b ; AM (98); HY (97); Lai01b ; Lai (05).

• •

A basis for compositional program verification AGMO (04); Ghi (09).

There is much ongoing work MT (09); MT11b ; MT11a , and this continues to be a flourishing field.111See e.g. https://sites.google.com/site/galopws/ for a workshop series devoted to this topic.

In a broader context, we can regard game semantics as a first step towards developing a positive theory of intensional structures with a robust mathematical structure, and finding the right notions of invariance.

0.2 Intensionality vs. Extensionality

The notions of intensionality and extensionality carry symmetric-sounding names, but this apparent symmetry is misleading. Extensionality is enshrined in mathematically precise axioms with a clear conceptual meaning. Intensionality, by contrast, remains elusive. It is a “loose baggy monster”222Cf. Henry James on the Russian masters. into which all manner of notions may be stuffed, and a compelling and coherent general framework for intensional concepts is still to emerge.

Let us recall some basic forms of extensionality. For sets we have:

[TABLE]

This says that a set is completely characterized by its members.

For functions we have:

[TABLE]

This says that a function is completely characterized by the input-output correspondence (i.e. the set of input-output pairs) which it defines.

The common idea underlying these principles is that mathematical entities can be characterized in operational terms: mathematical objects should be completely determined by their behaviour under the operations which can be applied to them. In the case of sets, this operation is testing elements for membership of the set, while in the case of functions, it is applying functions to their arguments.

The basic question we are faced in seeking to make room for intensional notions is this: is intensionality just a failure to satisfy such properties? Or is there some positive story to tell?

We shall focus on the case of functions. Here we can say that the modern, extensional view of functions as completely determined by their graphs of input-output correspondences over-rode an older, intensional notion, of a function being given by its rule. That older notion was never adequately formalized. Much of modern logic, in its concern with issues of definability, can be seen as providing tools for capturing the old intuitions in a more adequate fashion.

0.2.1 Intrinsic vs. Extrinsic Properties of Functions

We shall now draw a distinction which will be useful in our discussion. We say that a property of functions

[TABLE]

is intrinsic if it can be defined purely in terms of $f$ (as a set of input-output pairs) and any structure pertaining to $A$ and $B$.

This is, of course, not very precise. More formally, we could say: if it can be defined using only bounded quantification over the structures $A$ and $B$. But we shall rest content with the informal rendition here. We believe that the distinction will be quite tangible to readers with some mathematical experience.

0.2.2 Examples

• •

$A$ and $B$ are groups. A function $f:A\rightarrow B$ is a group homomorphism if

[TABLE]

In general, homomorphisms of algebraic structures are clearly intrinsic in the sense we intend.

• •

$A$ and $B$ are topological spaces. A function $f:A\rightarrow B$ is continuous if $f^{-1}(U)$ is open in the topology on $A$ for every open subset $U$ of $B$. Here the topology is viewed as part of the structure.

0.2.3 A Non-example: Computability

Computability is not an intrinsic property of partial functions

[TABLE]

in this sense. In order to define whether a function is computable, we need to refer to something external; a process by which $f$ is computed. A function is computable if there is some algorithmic process which computes $f$. But what is an algorithmic process?

Here of course we can appeal to Turing’s analysis Tur (37), and to subsequent, axiomatic studies by Gandy et al. Gan (80); Sie (02). But note that, not only do we have to appeal to some external notion of machine or algorithmic process, but there is no single canonical form of external structure witnessing computability. Rather, we have a confluence: all ‘reasonable’ notions lead to the same class of computable functions. But this confluence still leaves us with an extrinsic definition, and moreover one in which the external witness has no canonical form.

More concretely, suppose we are given some function

[TABLE]

i.e. a predicate on binary strings. To say that whether such a function is computable is an extrinsic property of $f$ simply means that we cannot say if $f$ is computable just by looking at its input-output graph and properties relating to the structure of $\{0,1\}^{*}$ and $\{0,1\}$. Clearly, we need something more, typically either:

• •

A suitable notion of machine, or

• •

An inductive definition given by some ‘function algebra’ or logical theory.

0.2.4 A comparison point: regular languages

One might reasonably ask what it would even mean to have an intrinsic (or, at least, more intrinsic) way of defining computability. For this purpose, it is useful to consider a much simpler notion which pertains to (sub-)computability in a non-trivial fashion, and which does admit an intrinsic definition in our sense.

Such an example is provided by regular languages, i.e. those accepted by finite-state automata HU (79).

Let $A$ be some finite alphabet. We write $A^{*}$ for the set of finite words or strings over this alphabet. Given a language $L\subseteq A^{*}$, we define

[TABLE]

Clearly, $\equiv_{L}$ is an equivalence relation on $A^{*}$.

Theorem 0.2.1 (Myhill-Nerode Myh (57); Ner (58))

$L$* is regular if and only if $\equiv_{L}$ is of finite index (i.e. has finitely many distinct equivalence classes).*

Of course, computability is a much richer notion than regularity, and one may well suppose that for metamathematical reasons, no intrinsic or quasi-intrinsic definition of computability can be achieved — although we are not aware of any specific formal result which implies this.

Still, the question seems worth asking: we suspect that a better understanding of this issue may be important in addressing some fundamental questions in computability and complexity. We shall return briefly to this point in the concluding section.

0.3 From functions to functionals

The issues become clearer if we include functionals (functions which take functions as arguments) in our discussion. This leads to the following hierarchy of types:

[TABLE]

In general, a type $n+1$ functional takes type $n$ functionals as arguments. Of course, more general types can also be considered.

Functionals are not so unfamiliar: e.g. the quantifiers!

[TABLE]

Here $\mathbb{B}$ is the set of truth-values; the quantifiers over the natural numbers are seen as functionals taking natural number predicates to truth-values.

While it might seem that bringing functionals into the picture will merely complicate matters, in fact when we consider higher-order functions, some intrinsic structure emerges naturally, which is lacking when we only look at first-order functions over discrete data.

When we compute with a function (or procedure) parameter $P$, we can immediately distinguish two paradigms.

• •

Extensional paradigm: the only way we can interact with $P$ is to call it with some arguments, and use the results:

[TABLE]

In any finite computation, we can only make finitely many such calls, and hence ‘observe’ a finite subset of the graph of the function defined by $P$:

[TABLE]

• •

Intensional paradigm: we have access to the code of $P$. So we can compute such things as the code itself (as a text string), or how many symbols appear in it, etc. Examples: interpreters, program analyzers, and other programs which manipulate programs. Usually, though, in computer science we keep programs as data (subject to manipulation) distinct from programs as code (performing manipulations); it is generally seen as bad practice to mingle these two modes. By contrast, computability theory does use codes of programs viewed as data in a pervasive and essential fashion. We shall return to this contrast when we discuss fixpoint theorems.

0.3.1 Intrinsic structure of computable functionals

When we pass to functionals, some intrinsic structure begins to emerge. Firstly, there is a natural ordering on partial functions:

[TABLE]

Here $\mathsf{graph}(f)$ is the set of input-output correspondences which — on the extensional view — uniquely characterize $f$. If $P$ is a program code, we can define $\mathsf{graph}(P)$ to be the set of input-output correspondences defined by the (partial) function computed by $P$.

We can view a function which takes codes of programs and returns numbers as an (a priori intensional) functional. We say that such a function $F$ is extensional if $F(P)=F(Q)$ whenever $\mathsf{graph}(P)=\mathsf{graph}(Q)$, and hence defines a functional $\hat{F}:[\mathbb{N}\rightharpoonup\mathbb{N}]\rightharpoonup\mathbb{N}$.

We have the following classical result:

Theorem 0.3.1 (Myhill-Sheperdson MS (55))

An extensional computable functional $\hat{F}$ satisfies the following properties:

Monotonicity

: $f\sqsubseteq g\;\Rightarrow\;\hat{F}(f)\sqsubseteq\hat{F}(g)$.

Continuity

: For any increasing sequence of partial functions

[TABLE]

we have

[TABLE]

Moreover, there is a sort of converse (which still needs to appeal to the usual notion of computability for functions on the natural numbers).

0.3.2 Generalization to Domains

These ideas were elaborated into a beautiful mathematical theory of computation by Dana Scott and others. Domains are partial orders with least elements and least upper bounds of increasing sequences. The corresponding functions are the monotonic and continuous ones.

A function $f:D\rightarrow E$ is monotonic if, for all $x,y\in D$:

[TABLE]

It is continuous if it is monotonic, and for all $\omega$-chains $(x_{n})_{n\in\omega}$ in $D$:

[TABLE]

Continuity serves as an ‘intrinsic approximation’ to computability: an intrinsic property which is a necessary condition for computability. Indeed, one speaks of ‘Scott’s thesis’, that computable functions are continuous Win (89). Of course, this condition is not sufficient, and hence does not offer a complete analysis of computability.

Examples

We consider functions $f:\{0,1\}^{\infty}\rightarrow\mathbb{B}_{\bot}$. Here $\{0,1\}^{\infty}$ is the domain of finite and infinite binary sequences (or ‘streams’), ordered by prefix; while $\mathbb{B}_{\bot}=\{\mathbf{tt},\mathbf{ff},\bot\}$ is the ‘flat’ domain of booleans with $\mathbf{tt}\sqsupseteq\bot\sqsubseteq\mathbf{ff}$, representing computations which either fail to halt, or return a boolean value.

We consider the following definitions for such functions:

$f(x)=\mathbf{tt}$ if $x$ contains a 1, $f(x)=\bot$ otherwise. 2. 2.

$f(x)=\mathbf{tt}$ if $x$ contains a 1, $f(0^{\infty})=\mathbf{ff}$, $f(x)=\bot$ otherwise. 3. 3.

$f(x)=\mathbf{tt}$ if $x$ contains a 1, $f(x)=\mathbf{ff}$ otherwise.

Of these: (1) is continuous, (2) is monotonic but not continuous, and (3) is not monotonic.

The conceptual basis for monotonicity is that the information in Domain Theory is positive; negative information is not regarded as stable observable information. That is, if we are at some information state $s$, then for all we know, $s$ may still increase to $t$, where $s\sqsubseteq t$. This means that if we decide to produce information $f(s)$ at $s$, then we must produce all this information, and possibly more, at $t$, yielding $f(s)\sqsubseteq f(t)$. Thus we can only make decisions at a given information state which are stable under every possible information increase from that state. This idea is very much akin to the use of partial orders in Kripke semantics for Intuitionistic Logic Kri (65), in particular in connection with the interpretation of negation in that semantics.

The continuity condition, on the other hand, reflects the fact that a computational process will only have access to a finite amount of information at each finite stage of the computation. If we are provided with an infinite input, then any information we produce as output at any finite stage can only depend on some finite observation we have made of the input. This is reflected in one of the inequations corresponding to continuity:

[TABLE]

which says that the information produced at the limit of an infinite process of information increase is no more than what can be obtained as the limit of the information produced at the finite stages of the process. Note that the “other half” of continuity

[TABLE]

follows from monotonicity.

0.3.3 The Fixpoint Theorem

Theorem 0.3.2 (The Fixpoint Theorem LNS (82))

Let $D$ be an $\omega$-cpo with a least element, and $f:D\rightarrow D$ a continuous function. Then $f$ has a least fixed point $\mathsf{lfp}(f)$. Moreover, $\mathsf{lfp}(f)$ is defined explicitly by:

[TABLE]

This is a central pillar of domain theory in its use in the semantics of computation, providing the basis for interpreting recursive definitions of all kinds Win (93); Gun (92). Note however that the key fixpoint result for computability theory is the Kleene second recursion theorem Kle (38); Mos (10), an intensional result, which refers to fixpoints for programs rather than the functions which they compute. This theorem is strangely absent from Computer Science, although it can be viewed as strictly stronger than the extensional theorem above. This reflects the fact which we have already alluded to, that while Computer Science embraces wider notions of processes than computability theory, it has tended to refrain from studying intensional computation, despite its apparent expressive potential. This reluctance is probably linked to the fact that it has proved difficult enough to achieve software reliability even while remaining within the confines of the extensional paradigm. Nevertheless, it seems reasonable to suppose that understanding and harnessing intensional methods offers a challenge for computer science which it must eventually address.

0.3.4 Trouble in Paradise

The semantic theory of higher-type functional computation we get from domain theory seems compelling. But there is a problem: a mismatch between what the semantic theory allows, and what we can actually compute in ‘natural’ programming languages.

Example: parallel or

We consider a (curried) function of two arguments

[TABLE]

[TABLE]

This is the ‘strong or’ of Kleene 3-valued logic.

This function lives in the semantic model, since it is monotonic and continuous, but it is not definable in realistic languages — or those arising from logical calculi (essentially, the $\lambda$-calculus). This is because a definable function of two arguments must examine its arguments in some definite order; whichever it examines first, the function will yield an undefined result if that argument is undefined. We can define second order functions which can only be distinguished by their values at parallel or; they will be observationally equivalent, i.e. equivalent in the operational sense, since no experiment we can perform within the language by applying them to inputs which can be defined in the language will serve to distinguish them. However, these second-order functions will have different denotations in a model which includes parallel or. Thus such a model — and in particular, the canonical domain-theoretic model — introduces operationally unjustified distinctions.

Note that definability and higher types are crucially important here. This mismatch between model and operational content is known as the failure of full abstraction Mil (77); Plo (77).

0.3.5 Sequentiality

Consider the following functions, which are definable:

[TABLE]

[TABLE]

Note that

[TABLE]

[TABLE]

To get $\mathsf{por}$, we need to run the processes for evaluating $b_{1}$ and $b_{2}$ in parallel. For example, we could interleave the executions of these processes, running each one step at a time. As soon as one of these returned the result $\mathbf{tt}$, we could return $\mathbf{tt}$ as the value of $\mathsf{por}$. This means that we need to have access, not just to the purely extensional information about the arguments — i.e. their values — but to their intensional descriptions. This form of dovetailing is fundamental to many constructions in computability theory Rog (67), but is not available in logical calculi and functional languages based on the $\lambda$-calculus. Indeed, contemporary functional programming languages take an extensional view of data as one of their cardinal virtues Hug (89); Wad (92); Tur (95).

This raises the question: how can we capture the notion of sequential functional?

0.3.6 Sequentiality is extrinsic

We need additional information to characterize those functionals which are sequential. The following remarkable result, due to Ralph Loader Loa (01), shows that this is unavoidable.

Theorem 0.3.3 (Loader)

The set of functionals definable in Finitary PCF, the typed $\lambda$-calculus over the booleans with conditionals and a term denoting $\bot$, is not recursive.

Note that, since the base type here is just the flat domain of booleans, the set of functionals at any type is finite. Thus if we form the logical type theory over this structure by closing under cartesian product and powerset, then all the logical types over this structure will also be finite. If there were any form of intrinsic definition of sequentiality, given in terms of some structure defined at each type even in full higher-order logic, this finiteness would ensure that the notion of sequentiality was recursive. By Loader’s theorem, we conclude that no such intrinsic definition can exist.333This argument is due to Gordon Plotkin (personal communication). This rules out any hope of a reasonable intrinsic definition of the sequential functionals. So the best we can do is to characterize which are the sequential functional processes — i.e. an intensional notion.

Attempts at such characterizations coming from a computability theory perspective were made by Kleene in his series of papers Kle (78, 80, 82, 85, 91), and by Gandy and Pani in unpublished work. The work of Berry and Curien on sequential algorithms on concrete data structures BC (82), directly inspired by the full abstraction problem for PCF, should also be mentioned.

A characterization of the sequential functional processes was eventually achieved using the newly available tools of Game Semantics, developed in the 1990’s by the present author, Radha Jagadeesan and Pasquale Malacaria, and by Martin Hyland and Luke Ong AJM (00); HO (00). We shall now give a brief account of these ideas.

0.4 Game Semantics

We shall give a brief, informal introduction to game semantics, emphasizing concepts and intuitions rather than technical details, for which we refer to works such as AJM (00); HO (00); Abr (97); AM99a .

The traditional approach to denotational semantics, exemplified by domain theoretic semantics Gun (92); Win (93), was to interpret the types of a programming language by (possibly structured) sets, and the programs as functions. Game semantics fundamentally revises this ontology:

• •

Types of a programming language are interpreted as 2-person games: the Player is the System (program fragment) currently under consideration, while the Opponent is the Environment or context.

• •

Programs are strategies for these games.

So game semantics is inherently a semantics of open systems; the meaning of a program is given by its potential interactions with its environment.

A key feature of game semantics as developed in computer science (and significantly differentiating it from previous work on games in logic Lor (60); HS (10)) is its compositionality. The key operation is plugging two strategies together, so that each actualizes part of the environment of the other. The familiar game-theoretic idea of playing one strategy off against another is a special case of this, corresponding to a closed system, with no residual environment. This form of interaction exploits the game-theoretic P/O duality.

0.4.1 Types as Games

• •

A simple example of a basic datatype of natural numbers:

[TABLE]

Note a further classification of moves, orthgonal to the P/O duality;the O-move ${q}$ is a question, the P-moves ${n}$ are answers. This turns out to be important for capturing control features of programming languages.

• •

Forming function or procedure types $A\Rightarrow B$. We form a new game from disjoint copies of $A$ and $B$, with P/O roles in $A$ reversed. Thus we think of $A\Rightarrow B$ as a structured interface to the Environment; in $B$, we interact with the caller of the procedure, covariantly, while in $A$, we interact with the argument supplied to the procedure call, contravariantly.

0.4.2 Example

We consider the strategy corresponding to the term $\lambda f:\mathbb{N}\Rightarrow\mathbb{N}.\,\lambda x:\mathbb{N}.\,f(x)+2$. This term defines the procedure $P(f,x)$ such that $P(f,x)$ returns $f(x)+2$.

We show a typical play for the strategy corresponding to this term in Figure 1.

This should be read as follows. Time flows downwards. Moves by Opponent alternate with those of Player. Each column corresponds to one of the occurrences of atomic types in the overall type of the term. Each of these will be a copy of the simple game for natural numbers. In effect, we are playing on several game boards, switching from one to another.

The play begins with the Opponent, or environment, requesting an output. The strategy must call the function argument $f$, so it requests an output from this argument. Note that the variance rules dictate that, since the type of $f$ occurs negatively in the overall type, this opening move is indeed a Player move. The environment now has to respond to this request. Typically, it will do so by requesting its input. Since the strategy is realizing the function call $f(x)$, the value of this input will be obtained by the strategy from the natural number argument $x$, and thus the strategy requests the value of this argument. When the evironment responds to this request with some number $n$, the strategy copies this value to answer the request of the function argument for its input. This copying of data is a key feature of game semantics, corresponding to the logical flow of information. Indeed, purely logical strategies, i.e. those corresponding to logical proofs, are typically made entirely from such ‘copy-cat’ processes AJ (94).

After the function argument receives its input $n$, it will typically emit some output $m$; the strategy for the term will now answer the original request from the environment with the number $m+2$.

We have simply described what the evident strategy corresponding to the above $\lambda$-term will do. Of course, the purpose of a compositional game semantics is precisely to allow this strategy to be constructed systematically as the denotation of the above term in a syntax-directed fashion.

0.4.3 Composition

We now show how the key operation of plugging one strategy together with another, corresponding to applying a procedure to its argument, or more generally to composing procedures, will proceed, again through an example. We apply the higher-order procedure $\lambda f:\mathbb{N}\Rightarrow\mathbb{N}.\,\lambda x:\mathbb{N}.\,f(x)+2$ to the argument $\lambda x:\mathbb{N}.\,x^{2}$. A typical run of the corresponding strategy is shown in Figure 2.

Here the common parts of the two strategies are shown in the dashed boxes. The key point is that type matching between function and argument guarantees that the Opponent moves for one are Player moves for the other, and vice versa. This intrinsic duality allows the interactive interpretation of composition to be defined without requiring any additional structure. Thus when the strategy for the functional plays its opening move in response to the environment request for an output, the other strategy sees this as the opening move of its environment, and responds accordingly. The functional now sees this response as the next move of the nvironment, and so on. With each of the strategies following their own scripts, we get a uniquely determined path through the common part of the type, where they interact.

Note that the residual strategy, after we hide the part where the interaction between function and argument occurs, is that corresponding to the function $\lambda x.\,x^{2}+2$, consistent with the result of performing $\beta$-reduction syntactically. This ‘parallel composition plus hiding’ paradigm for composition of strategies AJ (94) is a fundamental component of game semantics.

0.4.4 Technical Notes

Once the ideas shown informally by example in the previous subsection are properly formalized, games and strategies organize themselves into a very nice mathematical structure — a cartesian closed category $\mathcal{G}$ AJM (00); HO (00). We can then use standard methods of denotational semantics to give a compositional semantics for functional languages such as PCF in $\mathcal{G}$Gun (92).

The key result is:

Theorem 0.4.1 (Abramsky-Jagadeesan-Malacaria and Hyland-Ong AJM (00); HO (00))

Every compact (even: recursive) strategy in $\mathcal{G}$ is definable by a PCF term.

This can be understood as a completeness theorem. It is saying, not only that every sequential functional process can be interpreted as a strategy in the game semantics, but that the ‘space’ of strategies corresponds exactly to the class of sequential functional processes. In short, we have achieved a characterization, albeit at the intensional level.

Note that similar results can be achieved for proof calculi for various logical systems, leading to notions of full completeness AJ (94); AM99b .

If we refer to strategies as in our examples in the previous sub-section, we can get some intuition for how a result such as this is proved. The first move (by Player) in the strategy corresponds to the head variable in the head-normal form of the $\lambda$-term, or the last rule in a proof. Decomposing the strategy progressively uncovers the defining term. This argument is formalized in AJM (00); HO (00), and even axiomatized in Abr (99).

There is an important caveat, which actually leads to a major positive feature of game semantics. In order to achieve this completeness result, strategies must be constrained, as we shall now explain.

0.4.5 Constraints on Strategies

There are two main kinds of constraints which must be imposed on strategies in order to capture exactly the sequential functional processes:

Strategies do not have perfect information about the previous computation history (play of the game). For example, consider a call

[TABLE]

When it is evaluated (called) by $f$, $t_{2}$ should not ‘know’ whether $t_{1}$ has already been evaluated — and vice versa. Note that if we had imperative state, the arguments could use this to pass such information to each other. Thus this constraint is a distinctive feature of purely functional computation. 2. 2.

Properly nested call-return flow of control. This is visibly a feature of the example we discussed previously. It is often referred to as the ‘stack discipline’ AJM (00), for obvious reasons. It corresponds to the absence of non-local control features such as jumps or exceptions. Again, this constraint is a distinctive feature of purely functional computation.

Both these constraints can be formulated precisely (the first as ‘innocence’ or ‘history-freedom’, the second as ‘well-bracketing’), and shown to be closed under composition and the other semantic constructions AJM (00); HO (00). The resulting cartesian closed categories of games and constrained strategies yield the completeness results as in Theorem 0.4.1.

0.4.6 Discussion

It should be noted that there is an important caveat to the result in Theorem 0.4.1. We get a definability result — but strategies are much finer grained than functions. They correspond to certain ‘PCF evaluation trees’ AJM (00). To get an equationally fully abstract model, we must quotient the games model. This is unavoidable by Loader’s Theorem, from which it follows that the fully abstract model, even for Finitary PCF, is not effectively presentable.

What is the significance of the result? In retrospect, the real payoff is in other cases — but the PCF result is the keystone of the whole development. Relaxing the constraints which characterize functional computation leads to fully abstract models for languages with (locally scoped) state, or control operators, or both AM99a . This picture of a semantic ‘cube’ or hierarchy of constraints has proved very fruitful as a paradigm for exploring a wide range of programming language features.

0.4.7 The Game Semantics Landscape

Game semantics has proved to be a flexible and powerful paradigm for constructing highly structured fully abstract semantics for languages with a wide range of computational features:

• •

(higher-order) functions and procedures AJM (00); HO (00)

• •

call by name and call by value HY (97); AM (98)

• •

locally scoped state AM (97); MT (09)

• •

general reference types AHM (98); MT11b

• •

control features (continuations, exceptions) Lai (03); Lai01b

• •

non-determinism, probabilities HM (99); DH (02)

• •

concurrency Lai (05); Lai01a ; GM (08)

• •

names and freshness AGM*+* (04); Tze (07).

In many cases, game semantics have yielded the first, and often still the only, semantic construction of a fully abstract model for the language in question. Moreover, where sufficient computational features (typically state or control) are present, then the observational equivalence is more discriminating, and game semantics captures the fully abstract model directly, without the need for any quotient. Intensions become extensions!

More generally: the point of conceptual interest is to find positive reasons — structural invariants — for non-expressiveness. This is a positive story for a form of intensionality. Indeed, we can see here the beginnings of a structural theory of processes.

0.4.8 Mathematical Aside

Categories of games and strategies have fascinating mathematical structure in their own right. They give rise to:

• •

Constructions of free categories with structure of various kinds.

• •

Full completeness results characterizing the “space of proofs” for various logical systems AJ (94); AM99b .

• •

There are even connections with geometric topology, e.g. Temperley-Lieb and other diagram algebras Abr (07).

0.4.9 Algorithmic Game Semantics

We can also take advantage of the concrete nature of game semantics. A play is a sequence of moves, so a strategy can be represented by the set of its plays, i.e. by a language over the alphabet of moves, and hence by an automaton.

There are significant finite-state fragments of the semantics for various interesting languages, as first observed by Ghica and McCusker GM (03); Abr (01). This means we can compositionally construct automata as (representations of) the meanings of open (incomplete) programs, giving a powerful basis for compositional software model-checking. There has been an extensive development of these ideas in the last few years, by Ghica, Ong, Murawski, Tzevelekos et al. AGMO (03); LMOW (08); Ghi (09); MT (12).

0.4.10 Other Aspects

It should also be noted that there are other strands in game semantics, which has become a rich and diverse field. For example, there is work on clarifying the mathematical structure of game semantics itself, and its relation to syntax and to categorical structure. Examples include Mel (06, 12); HHM (07); Win (12); CF (12).

More broadly, we must emphasise that our subject in this paper has been the characterisation of sequential, functional processes. We have argued that a considerable measure of success has been achieved in answering this question. However, finding a compelling answer to the general question of “What is a process?” which we raised in the Introduction remains a major challenge of the field. It is likely that new conceptual ingredients will be needed to enable further advances towards this goal.

0.5 Conclusions: Some Questions and Dreams

• •

Can we use intensional recursion to give more realistic models of reflexive phenomena in biology, cognition, economics, etc.?

Working with codes seems more like what biological or social mechanisms might plausibly do, rather than with abstract mathematical objects in extenso.

• •

How does this relate to current interest in higher categories, homotopy type theory etc. AW (09); Voe (10), where equalities are replaced by witnesses? Do higher categories, and the intensional type theories they naturally support, provide the right setting for a systematic intensional view of mathematics and logic? What kind of novel applications will these structures support?

• •

Can we develop a positive theory of intensional structures, and find the right notions of invariance?

• •

The dream: to use this to give some (best-possible) intrinsic characterization of computability, and of complexity classes.

• •

Could this even be the missing ingredient to help us separate classes? Well, we can dream!