Internship Report Game Semantics and Normalization by Evaluation for Brouwer Ordinals

Transcription

1 Internship Report Game Semantics and Normalization by Evaluation for Brouwer Ordinals Léo Exibard August 28, 2015 Abstract P. Clairambault and P. Dybjer developed a Normalization by Evaluation (NbE) algorithm for presenting Hyland and Ong s game semantics for PCF with lazy natural numbers and their isomorphic representation of PCF-Böhm trees. NbE is used to compute PCF-Böhm trees by interpreting PCF programs in a model and then reifying them. We essentially use that our meta-language is the lazy functional language Haskell. During this internship, we extended the notion of PCF-Böhm tree to a version of PCF with a type of Brouwer ordinals. We then extended the NbE algorithm for computing PCF-Böhm trees to this extended language, thus opening way to more general infinite data structures. 1 Introduction Games have provided a very fruitful approach for elaborating semantics for programming languages and proofs. Indeed, game semantics have given the first syntax-independent model of PCF to enjoy full abstraction. Types are then viewed as games, and programs correspond to strategies of these games. These models offer a fine-grained, intensional vision of proofs and programs. Moreover, extending PCF with control or state corresponds to relaxing very natural conditions on the corresponding strategies (well-bracketing and innocence respectively). In this paper, we will focus on the notion of PCF-Böhm trees, that can easily be interpreted as strategies. In [5], P. Clairambault and P. Dybjer developed a Normalization by Evaluation algorithm to compute lazily operations on PCF- Böhm trees. We will introduce a version of PCF with Brouwer ordinals, and extend the notion of PCF-Böhm tree and the NbE algorithm. 2 Game semantics 2.1 Informal presentation It is better to approach games informally first, since they correspond to a simple intuition. In game semantics, the interaction between a program and its environment is modeled as a two-player game, Player (P) being the program, 1

2 and Opponent (O) the environment. P and O play in an arena corresponding to the type of the program, each having at his disposition a set of moves, possibly enabled by previous moves of its adversary. For example, the function f = Not : Bool Bool would be represented as follows: Opponent (the environment) starts by asking Player (the program) for the output Player asks for a particular input Opponent gives an input b {tt, ff} Player replies with Not(b). This interaction is better seen as a diagram, where O stands for Opponent, P for Player, Q for Question and A for Answer. Here, Player is asked to compute Not(tt): Bool Bool q Bool q Bool tt P Q OA ff In this example, Player examines its input. However, he is not forced to do so. For example, if f = TT is the constant function x tt, he could also reply directly (call-by-need): Bool Bool P A q Bool tt Many variations are allowed: another possible modelization of TT could be that Player asks for input even if he does not need it, and this would lead to different behaviours when the input does not terminate. Making explicit the action of asking for input is one of the most interesting features of game semantics, because it allows a very fine-grained modelization of programs. 2.2 Formalization Here, we follow [3] and [4]. Definition 1 (Arena). An arena is a tuple (M A = M P A M O A = M Q A M A A, A, I A ) 1 where: P A 1 denotes the disjoint union. The least upper bound will be denoted with. 2

3 M A = MA P M A O = M Q A M A A is the set of moves. The partition M A = MA P M A O tells if a move belongs to Player (P) or Opponent (O), and M A = M Q A M A A if it is a Question (Q) or Answer (A). We will write MA P = M A O to get the complementary set. A M A M A is the enabling relation: we write m A n when the move m enables the move n (we can also say that n is justified by m). We require A to satisfy the following constraints: Alternation between P and O: A M O A M P A M P A M O A An answer cannot justify another: A (M A A M A A ) = I A MA O is the set of initial moves (in our setting, we require that Opponent starts). Thus, an arena is a bipartite graph (M O A M P A, A), where the initial moves are distinguished vertices. In the rest of the paper, we will draw this graph to represent an arena. Definition 2 (Dual arena). The dual of an arena A = (M A, A, I A ) is A = (M A = M A {q A }, A = A {(q A, q A )}, I A = {q A }) where M P A = M O A and M O A = M P A {q A } and q A M Q. A Simply put, it is the same arena as A where the roles of O and P are inverted, with an additional move q A so that O starts. Now, we have to define what kind of plays are allowed on these arenas: Definition 3 (Legal Play). Let A be an arena. A play P MA is a justified sequence, ie a word such that each non-initial move n has a pointer to a previous move m such that m A n. We write L A for the set of legal plays on the arena A. Now, we can describe how players interact, by defining a notion of strategy. In the following, s will denote a string in M A, and a, b, c elements of M A. Definition 4 (Strategy). A strategy is a subset σ L A that satisfies: Even length: s σ, s 2Z. Even length prefix closed: sab σ s σ The (even-length) prefix closure allows to represent strategies as forests, and trees when only one initial move is considered. For example, σ = {ε, qa, qaq 1 b, qaq 2 c} q 1 b can be represented as 2 : q a c A strategy is said to be deterministic when, moreover, sab, sac σ b = c (we recall that s 2Z). Here, we will only be interested in deterministic strategies. 2 For reasons of space, we make trees grow to the right when possible. q 2 3

4 q Nat 0 succ P A Figure 1: Nat, an arena for lazy integers A first example: the arena Nat for lazy integers Lazy integers are accessed via the corresponding iterations of the succ operator, one at a time. Thus, an arena for lazy integers is Nat = ( M Nat = {q Nat, 0, succ}, Nat = {(q Nat, 0), (q Nat, succ), (succ, q Nat )}, I Nat = {q Nat } ), of which a graphical representation is given in fig 1. For example, the strategy for 1 = succ 0 would be: q Nat succ q Nat An example of arena for a more complex recursive type: α lists In fig 2 is pictured an arena for α lists. q α list [] cons q head P A α Figure 2: An arena for α lists A strategy for the list [1; 0] = cons(succ(0), cons(0, [])) in the arena of integer lists can then be seen in fig An arena for Brouwer ordinals O is the set of Brouwer ordinals inductively generated by: 0 O O 3 Here, we recall that as strategy is a set of plays, represented in the figure as a tree. 4

5 q int list cons q head succ 0 q head 0 q tail cons q tail [] Figure 3: A strategy for the list [1; 0] succ O n O if n O sup O b O if b N O An arena for Brouwer ordinals can be Ord, pictured in fig 4. However, contrary to the set O, this arena allows strategies representing partial elements; we will need to add constraints to get a good representation of O, as discussed in section 5.8. q Ord 0 O succ O sup O P A q Nat Ord Nat q Nat 0 succ P Q OA Figure 4: The arena Ord for Brouwer ordinals A strategy for ω = sup(λn.inj Nat Ord (n)) (where inj Nat Ord denotes the natural injection of Nat into Ord) can be seen in fig 5. 3 Lazy PCF PCF is a core functional programming language for which game semantics have been developed. Program are then interpreted as strategies, or equivalently, as PCF-Böhm trees. For a more comprehensive presentation of the topic, see [8]. In this section, we will present the lazy variant of PCF of [5], which have been the base of this work. 5

6 q Ord sup O P A q Nat Ord q Nat P Q 0 succ OA 0 O succ O P A inj Nat Ord 0 succ OA 0 O P A Figure 5: A strategy for ω 3.1 Syntax Lazy PCF syntax is: M ::= x λx.m M M 0 succ M case M M M fix M Ω Note that here, we use lazy instead of flat integers: an integer n is syntactically represented by succ n 0, not by n. This difference will allow us to treat integers lazily in the semantics. 3.2 Typing Terms are typed, the types being T ::= Nat T T. We notice that the type of a term is necessarily of the form T 1 T n Nat. We then write Γ M : T to say that M is of type T in the context Γ = x 1 : T 1,..., x n : T n. 3.3 Semantics The semantics of Lazy PCF are fully described in [5], so we will only write PCF reduction rules to give the reader an intuitive understanding of the language (id represents keeping the same De Bruijn indices, p consists in going down one De Bruijn level, ie incrementing every De Bruijn indices, and q is the singleton of the variable of De Bruijn index 0): 6

7 Computation rules: η-expansion rules: Commuting conversions: app (λ b) a β1 b[ id, a ] case 0 b c β2 b case (succ a) b c β3 c[ id, a ] fix c δ c[ id, fix c ] Ω Ω Ω c η1 λ (app (c[p]) q) a η2 case a 0 (succ q) case (case a b f) b f γ1 case a (case b b f) (case f (b [p]) (f [ pp, q ])) app (case a b f) c γ2 case a (app b c) (app f (c[p])) We draw the reader s attention to the fact that constructors such as case are variable-binding. 3.4 Arenas for PCF Here, we describe how to build arenas for the types of PCF, so that a well-typed term can be modeled as a strategy on the corresponding arena. As seen in section 3.2, we only need an arena for Nat, which is pictured in figure 1, and an arena for T T : Definition 5 (Arrow arena). Let A = (M A, A, I A ) and B = (M B, B, I B ) be two arenas. We build the arrow arena A B as follows: M A B = M Ai M Bo. Here, we label the moves with indices i and o to distinguish between the Input and the Output arenas. The indices will be removed when there is no ambiguity. M O A B = M P A M O B M P A B = M O A M P B A B = A B (I B I A ) I A B = I B Let s have a look at how plays unroll on this arena: First, O asks for output with a move of I B. Then, P can either directly answer with a move of M B or ask for input with a move of I A. 7

8 The play keeps unrolling with O either giving more input or asking for more output, and P conversely either giving more output or asking for more input. For example, the arena for Nat Nat is pictured in fig 6. Here, we make the difference between the two copies of Nat explicit, by specifying which one is the output (o) and which one is the input (i). q Nato 0 o succ o P A q Nati P Q 0 i succ i Figure 6: The arena for Nat Nat OA Definition 6 (Copycat strategy). On arenas of the form A A, we can define the copycat strategy cc A, where P just repeats the move previously made by O. It can be interpreted as the identity function. Formally, σ (M A A ) is a copycat strategy when sab (M A A ), sab σ a = b. 3.5 Lazy PCF Böhm trees Böhm trees were introduced for the untyped lambda calculus in [1], and were aimed to be a generalization of normal form, for lambda-terms where the normalization process may not terminate. They were extended to PCF by Curien (see e.g. [7]), as a representation for Hyland and Ong s game semantics for PCF. In [5], Clairambault and Dybjer extended it to lazy PCF. To compute the PCF-Böhm tree of a term t : T 1 T n Nat, we first compute its η-long head normal form λx 1... x n.case (x t 1 t m ) M N or 0 or succ M, and then recursively compute the PCF-Böhm trees of t 1,, t m, M and N. For example, the PCF-Böhm tree of a variable x is pictured in fig 7. It corresponds to the copycat strategy on the arena Nat. A more complex example is the addition of two integers represented by the term x + y = λx.fix(λf.λy.case y x (λm.succ (fm))). It is pictured in fig 8 (where cc(x) denotes the PCF-Böhm tree of the copycat strategy against x). 3.6 Terms and strategies We now expose the ideas behind the identification between PCF-Böhm trees and strategies. 8

9 case x 0 succ λy.case y 0 succ Figure 7: The PCF-Böhm tree of cc(x) PCF-Böhm trees as strategies PCF-Böhm trees resemble strategies very closely, and we show in fig 9 how we can interpret a PCF-Böhm tree as a strategy Strategies as PCF-Böhm trees We now have to impose two additional conditions to show the converse equivalence, namely innocence and well-bracketing. Definition 7 (Views and innocent strategies). We introduce the notion of view, on which the notion of innocent strategy relies. Intuitively, the P view of a play s consists in discarding what happens between an O move and its justifier. In particular, an initial O move resets the play. Formally, the P view s of a play s is: ε = ε sn = s n (n P move) sm = m (m initial) sns m = sn m (m O move, m justified by n) A strategy is called innocent when a move only depends on the current P view of the play. In other words, σ is innocent when s σ s σ. Definition 8 (Well-bracketed strategy). A strategy is said to be well-bracketed when every answer is justified by the last unanswered question. Formally, σ is well-bracketed when s m s n σ m M ( ) A n M A P A s M A \M A Theorem 1 (PCF-Böhm trees and strategies). The set of PCF-Böhm trees of type T and the set of innocent, well-bracketed strategies on the arena T are isomorphic. Thus, PCF-Böhm trees provide a compact way of representing strategies corresponding to PCF programs. 9

10 λxy.case y cc(x) λy.case y succ λy.case y cc(x) succ... succ cc(x) Figure 8: The PCF-Böhm tree of x + y A proof of this theorem for non-lazy PCF-Böhm trees can be found in [8], but it is easily adapted to our Lazy-PCF setting. 4 Normalization by Evaluation Normalization by evaluation was first introduced for typed λ-calculus in [2]. It consists in using the evaluation procedure of a host language to normalize the terms of the object language. In [5], Clairambault and Dybjer developed a NbE procedure in Haskell for computing operations on PCF-Böhm trees. Here, we give a quick sum-up of [5]. Thus, terms live in a syntaxic domain Tm, and they are then interpreted in a semantic domain D which satisfies: Lam D : (D D) D App D : D D D Succ D : D D Case D : D D (D D) D 0 D : D Var D : N D The interpretation function : Tm [D] D is defined as follows: 10

11 q To q Ti λx 1... x n.case x i : T 1 T i T n T o 0 succ M N strategy for M strategy for N q Nat 0 0 q Nat succ succ M strategy for M Figure 9: From PCF-Böhm trees to strategies fix f ρ = n N (λd. f (ρ :: d))n (Ω D ) app s t ρ = app D ( s ρ) ( t ρ) λt ρ = Lam D (λx. t (ρ :: x)) case a b c ρ = case D ( a ρ) ( b ρ) (λx. c (ρ :: x)) n ρ = ρ(n) succ a ρ = Succ D ( a ρ) Ω ρ = Ω D 0 ρ = 0 D app D and case D are two semantic operations that are defined in [5]. The { interpretation is then reified back to Tm using the reification } function ([D] D) Tm R n : f R D n (f [Var D (n i 1) 0 i n 1]) where n denotes the De Bruijn level of the term and R D n : D Tm is defined by: R D n 0 D = 0 R D n (Succ D d) = succ (R D n d) R D n (Lam D f) = λ (R D n+1 (f (Var D n))) R D n (Case D e d f) = case (R D n e) (R D n d) (R D n+1 (f (Var D n))) R D n (Var D i) = n i 1 R D n (App D e d) = app (R D n e) (R D n d) R D n Ω D = Ω 11

12 The Haskell code of this NbE procedure written by Clairambault and Dybjer, and extended by me as described in the following section, can be found at: PCF. Remark 1. The choice of using Normalization by Evaluation is independent of the fact that we investigate game semantics, and we could have used other methods to compute operations on PCF-Böhm trees. 5 Extending PCF with Brouwer ordinals We will now extend [5] to ordinals, as they are described in section Syntax The syntax of PCF is extended with: M O ::= M 0 O succ O M O sup O M O case O M O M O M O M O where (the productions of M and M O are merged) M ::= x λx.m O M O M O 0 succ M O case M O M O M O fix M O Ω Remark 2. Here, we choose to distinguish ordinals and natural numbers, instead of considering Nat as a subtype of O. This is technically a bit harder, but can be systematized more easily. 5.2 Typing We add a type for Brouwer ordinals, Ord. Thus, types are now T O = Nat Ord T O T O. Thus, the type of a term is of the form T 1 T n Base, where Base {Nat, Ord}. We add the following typing rules: Γ 0 O : Ord Γ o : Ord Γ succ O o : Ord Γ, Nat f : Ord Γ sup O f : Ord Γ o : Ord Γ a : A Γ, Ord b : A Γ, Nat Ord c : A Γ case O o a b c : A Figure 10: Additional typing rules for PCF+Ord 5.3 Semantics We extend the reduction rules with the following: Computation rules: case O 0 O b c d β2 b case O (succ O a) b c d β3 c[ id, a ] case O (sup O f) b c d β4 d[ id, f ] 12

13 η-expansion rules: Commuting conversion rules: o η2 case O o 0 O (succ O q) (sup O q) case (case O a b f g) b f γ1 case O a (case b b f ) (case f (b [p]) (f [ pp, q ])) (case g (b [p]) (f [ pp, q ])) case O (case O a b f g) b f g γ1 case O a (case O b b f g ) (case O f (b [p]) (f [ pp, q ]) (g [ pp, q ])) (case O g (b [p]) (f [ pp, q ]) (g [ pp, q ])) case O (case a b f) b f g γ1 case a (case O b b f g ) (case O f (b [p]) (f [ pp, q ]) (g [ pp, q ])) app (case O a b f g) c γ2 case O a (app b c) (app f (c[p])) (app g (c[p])) 5.4 Arenas for PCF+Ord We add the arena for Brouwer Ordinals depicted in figure 4, and, with the arrow construction, we can now build arenas for types of PCF+Ord terms, which are of the form T 1 T n Base. 5.5 Lazy PCF+Ord-Böhm trees We extend PCF-Böhm trees with Brouwer ordinals. The η-long head normal form can now also be λx 1... x n.case O (x t 1 t m ) M N P, 0 O, succ O M or sup O M. The PCF+Ord-Böhm tree is then obtained similarly, by recursively computing the PCF+Ord-Böhm trees of t 1,, t m, M, N and P. In figure 11, we show a graphical representation of these trees, the correspondance with strategies being very similar to the one pictured in figure 9. In the rest of the paper, we will say PCF-Böhm trees to refer to PCF+Ord- Böhm trees. 5.6 Extension of the NbE algorithm The semantic domain has to be extended accordingly, so we add the following constructors: 0 OD : D 13

14 λx 1... x n.case O (x i t 1 t m ) : T 1 (T i = A 1 A m Base) T n Base M N P 0 O succ O M sup O M Figure 11: PCF+Ord-Böhm trees Succ OD : D D Sup OD : (D D) D Case OD : D D (D D) ((D D) D) D The interpretation is then extended with: 0 O ρ = 0 OD succ O a ρ = Succ OD ( a ρ) sup O f ρ = Sup OD ( f ρ) case O a b c d ρ = case OD ( a ρ) ( b ρ) (λx. c (ρ :: x)) (λh. d (ρ :: (Lam D h))) where case OD : D D (D D) ((D D) D) D is a semantic operation defined as: case OD 0 OD e f g = e case OD (Succ OD d) e f g = f d case OD (Sup OD d) e f g = g d case OD (Case OD e d f g) e f g = Case OD e (case OD d e f g ) (λx.case OD (f x) e f g ) (λh.case OD (g h) e f g ) case OD (case D e d f) e f g = Case D e (case OD d e f g ) (λx.case OD (f x) e f g ) case OD (App D e d) e f g = Case OD (App D e d) e f g case OD (Var D i) e f g = Case OD (Var D i) e f g case D and app D are also extended with: case D (Case OD e d f g) e f = Case OD e (case D d e f ) (λx.case D (f x) e f ) (λh.case D (g h) e f ) 14

15 app D (Case OD e d f g) d = Case OD e (app D d d ) (λx.app D (f x) d ) (λh.app D (g h) d ) and finally, the reification function: R D n 0 OD = 0 O R D n (Succ OD d) = succ O (R D n d) R D n (Sup OD f) = sup O (R D n+1 (f (Var D n)) R D n (Case OD e d f g) = case O (R D n e) (R D n d) (R D n+1 (f (Var D n))) (R D n+1 (g (App D (Var D n)))) 5.7 Example: addition We define addition on ordinals (in Haskell) as: addordinals :: Ord -> Ord -> Ord addordinals x 0 = x addordinals x (S n) = S (addordinals x n) addordinals x (sup f) = sup (\n -> addordinals x (f n)) Expressed in our version of PCF with De Bruijn indices, we get: addordinals = λ(fix(λ(case O x 0 x 2 (succ O (app x 2 x 0 ))(sup O (app x 3 (app x 1 x 0 )))))) Now, let us examine the PCF-Böhm tree of ω + 1: succ O ω Here, there is nothing surprising since for ordinals, ω + 1 = succ(ω) A more interesting example is the PCF-Böhm tree of 1 + ω, in fig 12. To interpret this PCF-Böhm tree, we highlight the fact that in our setting, operators are variable-binding when necessary. Thus, the x 0 at level 2 refers to the variable bound by sup O, and the x 0 at level 4 refers to the variable bound by case O. This PCF-Böhm tree represents 1 + ω = sup O (λn.1 + n). We can notice that addition is recursive on the second argument, so this PCF-Böhm tree is infinite. Remark 3. We can see that the PCF-Böhm tree (and so the strategy) of 1 + ω is different from the one of ω, although they are equal if they are interpreted as classical ordinals with sup f = n 0 f(n). 5.8 Realizability for Brouwer ordinals It is now time to get back to arenas and strategies: our aim is to characterize the strategies on the arena for Brouwer ordinals (defined in figure 4) that actually represent a total Brouwer ordinal. Indeed, strategies such as the one in figure 13 are allowed (they are innocent and well-bracketed). An even more pathological example would be the strategy which does not even answer the first opponent question q Ord, representing O the totally undefined Brouwer ordinal. Such point can already be made about the modelization of Lazy PCF: arbitrary terms can be modeled, including non-terminating ones. However, if we want a more fine-grained correspondance between the game semantics of the 15

16 sup O 1 case O x 0 2 succ O succ O 3 0 O case O x 0 4 succ O succ O 5 0 O 6 Figure 12: The PCF-Böhm tree of 1 + ω q Ord sup O q Nat Ord Ω Figure 13: A partial strategy on the arena Ord programming language and the mathematical structures it represents, it is necessary to add constraints on strategies. In the following, we define a notion of realizability to achieve this for Brouwer ordinals. Intuitively, a strategy corresponds to a total Brouwer ordinal when it is either 0, the successor of a Brouwer ordinal or the sup of a total function in N O. Formally, a strategy realizes a Brouwer ordinal when it is: q O 0 O q O succ O O and O realizes a Brouwer ordinal. q O sup O f with f a strategy in the arena Nat Ord such that for every strategy n that realizes a total (lazy) natural number, the interaction between f and n realizes a Brouwer ordinal. The realizability of a lazy natural number can be defined very similarly to the one of Brouwer ordinals: q Nat 0 realizes a natural number. q Nat succ N realizes a natural number when N realizes a lazy natural number. 16

17 6 A (short) discussion on totality and well-foundedness The above discussion on realizability helps us grasp what is a good representation of Brouwer ordinals. However, one may have the feeling that this realizability notion is quite high-level, and wonder if it is possible to give a more direct characterization of the class of strategies modeling total well-founded elements. The following is an analysis of the notion of totality for strategies, which unfortunately does not correspond to the notion of totality and well-foundedness of the underlying elements. This notion of totality has already been widely discussed in [4, 6], but here, we wanted to analyze more closely what could be done in our particular setting, on an intuitive level. Definition 9 (Totality). We say that a deterministic strategy is total when it can respond to every O move. Formally, σ is called total when s σ, sa σ b, sab σ. At this point, we may hope that a total strategy models a total well-founded element. However, since infinite interactions are not forbidden, the following strategy is a total strategy on the arena Nat that does not correspond to a well-founded natural number: q Nat succ q Nat succ q Nat This strategy models the PCF term fix(λ(succ(x 0 ))), which can be interpreted as ω (here, we draw the reader s attention on the fact that we are talking about the mathematical ω, independently from its Brouwer ordinal representation sup O (λn.n) or its Nat representation succ(succ( ))). Moreover, we can also find strategies that are total but does not correspond to a total element. For example, the following strategy on Nat Nat is innocent, well-bracketed and total but represents a function which never terminates: q Nati q Nato q Nati 0 i 0 i q Nati succ i q Nati succ i q Nati It continuously asks for input, even when O has already answered. This kind of behaviour is known as stuttering. The phenomenon of infinite chattering is quite similar, when two strategies are composed and enter an infinite dialogue. To address this problem, Hyland introduced in [9] a notion of winning, to specify which infinite plays are allowed. Formally, a winning condition is a set W L ω A, where p Lω A is winning (for P) iff p W. Then, characterizing good strategies boils down to defining a proper winning condition. 7 Conclusion Our contribution In this work, we extended the NbE procedure of Clairambault and Dybjer to an infinite data structure, Brouwer ordinals. This extension opens way to computation of operations on Böhm trees of richer languages, thus providing a better understanding of game semantics for such languages. 17

18 Analyzing the notion of totality, both for elements and for strategies, and those of realizability and winning helped us grasp the relation between PCF terms and the elements they model, although it is very hard to distanciate from the high-level view inherited from the mathematical structures we built. Future work We lacked the time for extending Clairambault and Dybjer s proof of correctness of the NbE algorithm, so it should be developed for Lazy PCF + Brouwer ordinals. Since the extension of the algorithm is quite natural, this should not be too hard, but the only way to show that a proof is easy is to write it. The discussion on totality also opened way to the definition of a class of strategies that would represent total elements, independently from the arena. To the writer s knowledge, this has not yet been developed. References [1] H. P. Barendregt. The Lambda Calculus Its Syntax and Semantics, volume 103. North Holland, revised edition, henk/personal Webpage. [2] U. Berger and H. Schwichtenberg. An inverse of the evaluation functional for typed lambda -calculus. In [1991] Proceedings Sixth Annual IEEE Symposium on Logic in Computer Science, pages IEEE Comput. Sco. Press, July [3] Pierre Clairambault. Least and greatest fixpoints in game semantics. In Foundations of Software Science and Computational Structures, 12th International Conference, FOSSACS 2009, Held as Part of the Joint European Conferences on Theory and Practice of Software, ETAPS 2009, York, UK, March 22-29, Proceedings, pages 16 31, [4] Pierre Clairambault. Logique et Interaction : une Étude Sémantique de la Totalité. Theses, Université Paris-Diderot - Paris VII, February [5] Pierre Clairambault and Peter Dybjer. Game semantics and normalization by evaluation. In Foundations of Software Science and Computation Structures - 18th International Conference, FoSSaCS 2015, Held as Part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2015, London, UK, April 11-18, Proceedings, pages 56 70, [6] Pierre Clairambault and Russ Harmer. Totality in arena games [7] Pierre-Louis Curien. Abstract böhm trees. Mathematical. Structures in Comp. Sci., 8(6): , December [8] Pierre-Louis Curien. Notes on game semantics. September [9] Martin Hyland. Game semantics. Semantics and Logics of Computation, pages , September

19 8 About the internship Lab and team My work was conducted in the Department of Computer Science and Engineering Department of the Chalmers University of Technology in Göteborg, under the supervision of Peter Dybjer, in the PROGLOG team. Interactions I had very interesting discussions with Peter Dybjer about this internship and related topics (game semantics, logic, dependent types, ), but also on more general matters such as his personal experience of research and how to give a good direction to a research work. I also interacted with other members of the team, particularly Anders Mörtberg, a post-doc who was working on Cubical Type Theory, and Simon Huber, who presented his licentiate thesis about Cubical Sets; and finally Théo Winterhalter, Victor Delage and Paul Laforgue, three interns who were working on type theory and proof assistants. Informal talks I attended a talk by Marcello Fiore (who had been invited by the PROGLOG team) about free algebras and category theory, and, at the end of my internship, gave a talk about my work. Agda Implementors Meeting I also attended the twenty-first Agda Implementors Meeting, a biannual meeting during which people interested in the proof assistant Agda and related topics (other proof assistants, logic, programming language semantics, ) gather to present their research and discuss the implementation of Agda s features. Two talks particularly drew my attention, one by Ulf Norell (the implementor of Agda 2), Reflexions about reflection, on how to add reflection features to Agda, and one by Peter Dybjer about the meaning explanations of Martin-Löf type theory, which raised very interesting philosophical questions. Related topics During my internship, I learned the basics of category theory, to be able to understand the construction of the category of games. I also got more familiar with programming language semantics, to get a more general point of view on my work. At one point, I learned a lot about type theory, and in particular about dependent types, because I tried to develop game semantics for these types (it was however a little ambitious for a 3 months internship). On more practical matters, I familiarized with Haskell to understand Clairambault and Dyber s implementation of the NbE algorithm, and to extend it to Brouwer ordinals. Although I did not go into the depth of the language, I got a nice glimpse of the power of this purely functional language, in particular with the category-inspired concept of monad. I also read and wrote Agda code, both during the Agda meeting and when P. Dybjer sent me pieces of code that explained and formalized the concepts we were working with. 19