Explicit Substitutions

(1)

Explicit Substitutions

Benedetto Intrigila¹, Giulio Manzonetto^?2, and Nicolas M¨unnich^??2

1 Dipartimento di Ingegneria dell’Impresa, University of Rome “Tor Vergata”, Italy [email protected]

2 USPN, Sorbonne Paris Cit´e, LIPN, UMR 7030, CNRS, F-93430, France {manzonetto,munnich}@lipn.univ-paris13.fr

Abstract. Addressing machines have been introduced as a formalism to construct models of the pure, untypedλ-calculus. We extend the syntax of their programs by adding instructions for executing arithmetic operations on natural numbers, and introduce a reflection principle allow- ing certain machines to access their own address and perform recursive calls. We prove that the resulting extended addressing machines naturally model a weak call-by-namePCFwith explicit substitutions. Finally, we show that they are also well suited for representing regularPCFpro- grams (closed terms) computing natural numbers.

Keywords: Addressing machines·PCF·explicit substitutions.

Introduction

Turing machines (TM) andλ-calculus constitute two fundamental formalisms in theoretical computer science. Despite their equivalence on partial numeric functions given by Church-Turing thesis, there are no models ofλ-calculus based on TM’s, since higher-order calculations are difficult to emulate in a TM. Recently, Della Penna et al. have successfully built a λ-model based on so-called addressing machines (AM) [9]. These machines are solely capable of manipulating the addresses of other machines — this opens the way for modelling higher-order computations since functions can be passed via their addresses. An AM can read an address from its tape, store the result of applying an address to another and pass the execution to another machine by calling its address. The set of instructions is deliberately small, to identify the minimal setting needed to represent λ-terms. The downside is that performing calculations on natural numbers in an AM is as awkward as using Church numerals in λ-calculus.

So we extend the formalism of AM’s with instructions representing basic arithmetic operations and conditional tests on natural numbers. As we are en- tering a world of machines and addresses, we need specific machines to represent numerals and assign them recognizable addresses. Finally, to model recursion, we

?Partly supported by ANR Project PPS, ANR-19-CE48-0014.

?? Partly supported by ANR Project CoGITARe, ANR-18-CE25-0001.

(2)

rely on the existence of machines representing fixed-point combinators — these machines can be programmed in the original formalism but we need as an exter- nal assumption that they have access to their own address. This can be seen as a very basic version of the reflection principle in some programming languages.

We call the resulting formalismextended abstract machines (EAMs).

Considering these features, one might expect EAMs to be well-suited for simulating Plotkin’s PCF[16], a simply typedλ-calculus with constants, arithmetical operations, conditional testing and a fixed point combinator. A PCF term of the form (λx.M)N can indeed be translated into a machineM reading as input (x) from its tape the address ofN. AsMhas control over the computation, it naturally models a weak leftmost call-by-name evaluation. However, while the contraction of the redex inM[N/x] is instantaneous,Mneeds to pass the address ofNto the machines representing the subterms ofM, with the substitution only being performed ifNgains control of the computation. As a result, rather thanPCF, EAMs naturally emulate the behavior ofEPCF— a weak call- by-namePCFwith explicit substitutions that are only performed “on demand”, as in [12]. We endow EAMs with a typing mechanism based on simple types and define a type-preserving translation from well-typedEPCFterms to EAMs.

Subsequently, we prove that also the operational behavior of EPCFis faithfully represented by the translation. Finally, by showing an equivalence betweenPCF andEPCFon terminating programs of typeint, we draw conclusions forPCF.

The paper is organized as follows. In Section 1 we introduce the language EPCF along with its syntax, simply typed assignment system and associated (call-by-name) big-step operational semantics. We assume familiarity with the standard (call-by-name) PCF, otherwise the reader may consult [15]. In Sec- tion 2 we define EAMs (no familiarity with [9] is assumed) and introduce their operational semantics. In Section 3 we describe a type–checking algorithm for determining whether an EAM is well-typed. In Section 4 we present our main re- sults, namely: (i) the translation of a well-typedEPCFterm is an EAM typable with the same type (Theorem 1); (ii) if an EPCF term big-step reduces to a value, then their translations as machines are interconvertible (Theorem 2); (iii) the operational semantics of PCFand EPCFcoincide on terminating programs of type int (Theorem 3); (iv) the translation of a PCF program computing a number is an EAM evaluating the corresponding numeral (Theorem 4).

Related works.A preliminary version of addressing machines appeared in Della Penna’s MSc thesis [8]. Presenting a comprehensive survey of all machine based formalisms introduced in the literature would be unrealistic. The most similar ones are likely by Fairbairn and Stuart [10], but they were studied with a specific focus on the implementation of supercombinators. The model based on AMs also bares some similarities with the categories of assembly used by Longley to model PCF [13], but more on a philosophical rather than implemen- tational level. For other models of PCF based on game semantics, the reader may consult [4,11]. Concerning explicit substitutions we refer to the pioneering articles [1,2,7,12]. As far as we can tell, they have been barely considered in the context ofPCF— with the notable exception of [17],

(3)

n∈N

σ . n⇓dn (nat)

σ . λx.Mhρi ⇓dλx.Mhσ+ρi (fun) σ(x) = (ρ, N) ρ . N⇓dV

σ . x⇓dV (var) σ . M·(fixM)⇓dV σ .fixM⇓dV (fix) σ . M⇓d0 σ . N1⇓dV1

σ .ifz(M, N1, N2)⇓dV1

(ifz0) σ . M⇓dn+ 1 σ . N2⇓dV2

σ .ifz(M, N1, N2)⇓dV2

(ifz>0) σ . M⇓dn+ 1

σ .predM⇓dn (pr) σ . M⇓d0

σ .predM ⇓d0 (pr0) σ . M⇓dn

σ .succM ⇓dn+ 1 (sc) σ . M⇓dλx.M⁰hρi ρ+ [x←(σ, N)]. M⁰⇓dV

σ . M·N⇓dV (βv) Fig. 1.The big-step operational semantics ofEPCF.

1 Preliminaries

The paradigmatic programming languagePCF[16] is a simply typed λ-calculus enriched with constants representing integers, the fundamental arithmetical operations, an if-then-else conditional instruction, and a fixed-point operator. We givePCFfor granted and rather presentEPCF, an extension ofPCFwith explicit substitutions [12]. We draw conclusions for the standardPCFby exploiting the fact that they are equivalent on programs (closed terms) of typeint.

Definition 1. Consider fixed a countably infinite set Var of variables. EPCF termsand explicit substitutionsare defined by (forn≥0 and~x∈Var):

L, M, N::= x|M ·N |λx.Mhσi

As is customary,M·Nstands for theapplicationof a termM to its argument N,0represents the natural number 0,predand succindicate the predecessor and successor respectively, ifz is the conditional test on zero, and finally, fix is a fixed-point operator. We assume that application – often denoted as jux- taposition – associates to the left and has higher precedence than abstraction.

Concerningλx.Mhσi, it represents an abstraction where σis an ordered list of assignments from variables toclosures (terms with the associated substitutions), where each variable can only have one closure assigned to it.

In an explicit substitutionσ= [x1 ←(σ1, M1), . . . , xn ←(σn, Mn)] thexi’s are assumed to be fresh and distinguished. So, we can defineσ(x_i) = (σ_i, M_i).

The domain of σ is given by dom(σ) = {x1, . . . , x_n}. We write σ+ρ for the concatenation ofσandρ, and in this case we assume dom(σ)∩dom(ρ) =∅.

The set FV(M) of free variables of an EPCF term M is defined as usual, except for the abstraction case FV(λx.Mhσi) = FV(M)−({x}+ dom(σ)). The termM isclosed if FV(M) =∅, and in that case it is called anEPCFprogram.

Hereafter terms are considered up to renaming of bound variables. Therefore the symbol = will denote syntactic equality up toα-conversion.

(4)

Notation 1. 1. For every n∈N, we let n=succⁿ(0). In particular, 0 is an alternative notation for0.

2. As a syntactic sugar, we writeλx.M forλx.Mhi. With this notation in place, PCFtermsare simply EPCFterms containing empty explicit substitutions.

3. For n ∈ N, we often write λx₁. . . λx_n.M as λx₁. . . x_n.M, or even λ~x.M when n is clear from the context. Summing up, and recalling that · is left associative,λx₁x₂x₃.L·M·N stands forλx₁.(λx₂.(λx₃.((L·M)·N)hi)hi)hi.

4. As usual, M[N/x] denotes the capture-free substitution of N for all free occurrences ofxin M.

Example 1. We introduce some notations for the following (E)PCF programs, that will be used as running examples.

1. I=λx.x, representing the identity.

2. Ω=fix(I) representing the paradigmatic looping program.

3. succ1=λx.succ(x), representing the successor function.

4. succ2= (λsn.s·(s·n))·succ1, representing the functionf(x) =x+ 2.

5. add aux=λf xy.ifz(y, x,(f ·(succx))·(predy)), i.e. the functional Φf(x, y) =

(x, ify= 0, f(x+ 1, y−1), ify >0.

6. add=fix(add aux), i.e., the recursive definition of additionf(x, y) =x+y.

The operational semantics ofEPCFis defined through a call-by-value big-step (leftmost) weak reduction.

Definition 2. 1. We letVal ={n|n∈N} ∪ {λx.Mhσi |M is anEPCFterm}

be the set ofEPCFvalues.

2. The big-step weak reduction is the least relation ⇓d from EPCF terms to Val, closed under the rules of Figure 1.

3. We say that an EPCF term M is terminating whenever M ⇓ V for some V ∈Val. Otherwise, we say that M is a non-terminating, or looping, term.

Example 2. We show some of the terms from Example 1, at work.

1. We have [ ].succ1·0⇓d1. To get the reader familiar with the operational semantics, we give the details:

[ ]. λx.succ(x)⇓d λx.succ(x) (fun)

[ ].0⇓d0 (nat) [x←([ ],0)]. x⇓d0 (var) [x←([ ],0)].succ(x)⇓d1 (sc) [ ].(λx.succ(x))·0⇓_d 1 (βv) 2. Similarly, [ ].I·4⇓d 4, [ ].I·I⇓dI, [ ].succ2·1⇓d3 and [ ].add·5·1⇓d6.

3. Since Ωis looping, there is noV ∈Val such that [ ].Ω⇓d V is derivable.

We now endowEPCFterms with a type system based on simple types.

(5)

Γ, x:α`x:α (ax)

Γ `0:int (0) Γ `M :α→α Γ `fixM :α (Y) Γ `M :int

Γ `succM :int (+) Γ `M :int

Γ `predM :int (−) Γ `L:int Γ `M :α Γ `N:α Γ `ifz(L, M, N) :α (ifz) σ|=∆ Γ, ∆, x:α`M:β

Γ `λx.Mhσi:α→β (→I) Γ `M :α→β Γ `N :α Γ `M·N :β (→E)

[]|=∅ (σ0) σ|=Γ ρ|=∆ ∆`M :α σ+ [x←(ρ, M)]|=Γ, x:α (σ) Fig. 2.EPCFtype assignment system.

Definition 3. 1. The setTof (simple) typesover a ground typeintis induc- tively defined by the grammar:

α, β ::= int|α→β (T)

The arrow associates to the right, in other words we writeα1→ · · ·αn →β forα1→(· · ·(αn→β)· · ·)(=~α→β, for short).

2. A typing context Γ is given by a set of associations between variables and types, writtenx1:α1, . . . , xn:αn. In this case, we letdom(Γ) ={x1, . . . , xn}.

When writingΓ, x:α, we silently assume thatx /∈dom(Γ).

3. Typing judgements are triples, denoted Γ ` M : α, where Γ is a typing context,M is anEPCFterm and α∈T.

4. Typing derivationsare finite trees built bottom-up in such a way that the root has shapeΓ `M :αand every node is an instance of a rule from Figure 2.

In the rule(→I)we assume wlog thatx /∈Γ, by α-conversion. We also use an auxiliary predicate σ|=Γ whose intuitive meaning is thatΓ is a typing context constructed from an explicit substitutionσ.

5. When writingΓ `M :α, we mean that this typing judgement is derivable.

6. We say that M is typable ifΓ `M :αis derivable for someΓ, α.

Example 3. The following are examples of derivable typing judgments.

1.

[ ]|=∅ (σ₀)

`0:int (0)

[y←([ ],0)]|=y:int (σ) y:int, x:α`y:int (ax) y:int, x:α`succ(y) :int (+)

`λx.succ(y)h[y←([ ],0)]i:α→int (→I) 2. `(λx.succ(x))·0:int.

3. `(λsn.s·(s·n))·(λx.succ(x)) :int→int.

4. `fix(λf xy.ifz(y, x, f·(succx)·(predy))) :int→int→int.

5. `Ω:α, for allα∈T.

(6)

The following lemma summarizes the main (rather standard) properties of the languageEPCF.

Lemma 1. Let M be an EPCFterm,V ∈Val,α, β∈TandΓ be a context.

1. (Syntax directedness) Every derivable judgementΓ `M :αadmits a unique derivation.

2. (Strengthening) If Γ, x:β`M :αandx /∈FV(M)thenΓ `M :α.

3. (Subject reduction) ForM closed, `M :αand[ ]. M ⇓dV entail `V :α.

It follows that, if anEPCFprogramM is typable, then it is also typable in the empty context.

2 Extended addressing machines

We extend the addressing machines from [9] with instructions for performing arithmetic operations and conditional testing. Natural numbers will be represented by particular machines playing the role of numerals.

2.1 Main definitions

We consider fixed a countably infinite setAofaddresses together with a distinguished countable subset X⊂A, such that A−X remains infinite. Intuitively, X is the set of addresses that we reserve for the numerals, therefore hereafter we work under the hypothesis that X = N, an assumption that we can make without loss of generality.

Definition 4. Let ∅∈/ Abe a “null” constant corresponding to an uninitialised register. SetA∅=A∪ {∅}.

1. AnA-valued tapeT is a finite ordered list of addressesT = [a₁, . . . , a_n]with a_i ∈ A for all i(1 ≤i ≤ n). When A is clear from the context, we simply callT a tape. We denote by T_A the set of allA-valued tapes.

2. Let a ∈ A and T, T⁰ ∈ T_A. We denote by a :: T the tape having a as first element andT as tail. We write T@T⁰ for the concatenation of T andT⁰, which is anA-valued tape itself.

3. Given an indexi≥0, anA∅-valued register Ri is a memory-cell capable of storing either ∅or an address a ∈A. We write !Ri to represent the value stored in the registerRi. (The notation!Ri is borrowed from OCaml, where

!represents an explicit dereferencing operator.)

4. Given A∅-valued registers R₀, . . . , R_n for n≥0, an address a∈A and an index i≥0, we write R[R~ i :=a] for the list of registersR~ where the value ofRi has been updated by setting !Ri =a. Notice that, wheneveri > n, we assume that the contents ofR~ remains unchanged, i.e. R[R~ i:=a] =R.~ Addressing machines are endowed with only three instructions (i, j, k, lrange over indices of registers):

(7)

1. Loadi: reads an addressafrom the input tape, assuming it is non-empty, and storesa in the registerR_i. If the tape is empty then the machine suspends its execution without raising an error.

2. k App(i, j) : reads the addresses a1, a2 from Ri and Rj respectively, and stores inR_k the address of the machine obtained by extending the tape of the machine of addressa₁ with the addressa₂. The resulting address is not calculated internally but rather obtained calling an externalapplication map.

3. Call i : transfers the computation to the machine having as address the value stored inRi, whose tape is extended with the remainder of the current machine’s tape.

As a general principle, writing on a non-existing register does not cause issues as the value is simply discarded — this is in fact the way one can erase an argument.

The attempt of reading an uninitialized register would raise an error — we however show that these kind of errors can be avoided statically (see Lemma 2).

We enrich the above set of instructions with arithmetic operations mimicking the ones present in PCF:

4. l Test(i, j, k): implements the “is zero?” test on !R_i. Assuming that the value ofR_i is an addressn∈N, the instruction stores inR_lthe value ofR_j orR_k, depending on whethern= 0.

5. j Pred(i): if !Ri∈N, then the value ofRj becomes !Ri⊕1 = !Ri+ 1.

6. j Succ(i): if !Ri∈N, the value ofRj becomes !Ri 1 = max(!Ri−1,0).

Notice that the instructions above needR_i to contain a natural number to perform the corresponding operation. However, they are also supposed to work on addresses of machines that compute a numeral. For this reason, the machine whose address is stored in Ri must first be executed, and only if the computation terminates with a numeral is the arithmetic operation performed. Clearly, if the computation terminates in an address not representing a numeral, then an error should be raised at execution time. We will see that these kind of errors can be avoided using a type inference algorithm (see Proposition 1, below).

Definition 5. 1. Aprogram P is a finite list of instructions generated by the following grammar, whereε represents the empty string andi, j, k, l are indices of registers:

P::=Load i;P|A

Thus, a program starts with a list of Load’s, continues with a list of App, Test,Pred,Succ, and possibly ends with aCall. Each of these lists may be empty, in particular the empty programεcan be generated.

2. Let P be a program, r ≥ 0, and I ⊆ {0, . . . , r−1} be a set of indices corresponding to the indices of initialized registers.

(8)

Define the relationI |=^rP as the least relation closed under the rules:

I |=^rε

i∈ I I |=^rCalli

I ∪ {j} |=^rA i∈ I j < r I |=^rj Pred(i);A I ∪ {i} |=^rP i < r

I |=^rLoad i;P

I |=^rP i≥r I |=^rLoad i;P

I ∪ {j} |=^rA i∈ I j < r I |=^rj Succ(i);A I ∪ {l} |=^rA i, j, k∈ I l < r

I |=^rl Test(i, j, k);A

I ∪ {k} |=^rA i, j∈ I k < r I |=^rk App(i, j);A

3. A program P is valid with respect to R₀, . . . , R_r−1 if R |=^r P holds for R={i|R_i6=∅ ∧ 0≤i < r}.

Example 4. For each of these programs, we specify its validity with respect to R0= 7, R1=a, R2=∅(i.e.,r= 3).

1. P1= 2 Pred(0);Call2 (valid)

2. P2=Load2;Load8; 1 Pred(0); 0 Test(0,1, 2);Call0 (valid) 3. P₃=Load0;Load2;Load8;Call8 (callingR₈, thus not valid) Lemma 2. GivenA∅-valued registersR~ and a programPit is decidable whether P is valid w.r.t.R.~

Proof. The grammar in Definition 5(1) is right-linear, so it is decidable whether P is a production. Also,r∈Nand therefore the setRin Definition 5(3) is finite.

SinceP is also finite, the setRremains finite during the execution ofR |=^rP. Decidability follows from these properties, together with the fact that the first instruction ofP uniquely determines which rule from Definition 5(2) should be applied (and these rules are exhaustive).

Definition 6. 1. An extended addressing machine(EAM)M withrregisters overAis given by a tuple:

M=

R0, . . . , R_r−1, P, T

whereR~ areA∅-valued registers, P is a program valid w.r.t. R~ andT ∈ T_A is an (input) tape.

2. We write M.r for the number of registers of M, M.Ri for its i-th register, M.P for the associated program and M.T for its input tape. When writing

“Ri=a” in a tuple we indicate thatRi is present and !Ri=a.

3. We say that an extended addressing machine M as above is stuck, written stuck(M), whenever its program has shapeM.P =Loadi;P but its input-tape is emptyM.T = []. OtherwiseM is ready, written¬stuck(M).

4. The set of all extended addressing machines over Awill be denoted byM_A. 5. Forn≥0, the n-th numeral machineis definedn=

R0, ε,[]

with!R0=n.

6. For n ≥ 0 and a∈ A, define Y_n^a =

(R0=a, R1=∅, . . . , Rn+1=∅,P,[]

where P=Load1;· · · ;Loadn+ 1; 0 App(0,1);· · ·; 0 App(0, n+ 1);

1 App(1,2);· · ·; 1 App(1, n+ 1); 1 App(1,0);Call1

(9)

Example 5. The following are examples of EAMs (whose registers are assumed uninitialized, i.e.R~ =∅~).

1. Succ1:=

R0,Load 0; 0 Succ(0);Call 0,[]

. LetaS= #Succ1.

2. Succ2:=

R0, R1,Load0;Load 1; 1 App(0,1); 1 App(0,1);Call 1,[aS] . 3. Add aux:=R, P,~ []

withAdd aux.r= 5 andP =Load0;Load1;Load2; 3 Pred(1); 4 Succ(2); 0 App(0, 3); 0 App(0,4); 0 Test(1,2, 0);Call0.

We now enter into the details of the addressing mechanism which constitutes the core of this formalism.

Definition 7. Recall that N stands for an infinite subset of A, here identified with the set of natural numbers, and Y^a_n has been introduced in Definition 6(6).

1. SinceM_Ais countable, we can fix a bijective function# :M_A→Asatisfying the following conditions:

(a) (Numerals)∀n∈N.#n=n, where nis then-th numeral machine;

(b) (Fixed point combinator) for alln≥0, there exists an addressa∈A−N such that

#(Y^a_n) =a.

We say that the bijection #(·) is an address table map and call the element #M the address of the EAMM. We simply write Yn for the machine satisfying the equation above andaY_n for its address, i.e.,#(Yn) =aY_n. 2. Fora∈A, we write#⁻¹(a)for the unique machine having addressa, i.e.,

#⁻¹(a) =M ⇐⇒ #M=a.

3. GivenM∈ M_A andT⁰∈ T_A, we writeM@T⁰ for the machine M. ~R,M.P,M.T@T⁰

.

4. Define theapplication map (·) :A×A→Aby settinga·b= #(#⁻¹(a) @ [b] ).

I.e., the application of a to b is the unique address c of the EAM obtained by addingb at the end of the input tape of the EAM#⁻¹(a).

Remark 1. It is easy to check that there are uncountably many possible address table maps, and some of them are even effective. Depending on the chosen address table map, it might be possible to construct infinite (static) chains of EAMs (M)_n∈N, e.g.,

Mn=

R0= #Mn+1, ε,[]

.

2.2 Operational semantics

The operational semantics of extended addressing machines is given through a small-step rewriting system. The reduction strategy is deterministic, since the only applicable rule at every step is univocally determined by the first instruction of the internal program, the contents of the registers and the head of the tape.

(10)

Unconditional rewriting rules DR,~ Calli;P, T

E

→c#⁻¹(!Ri) @T DR,~ Loadi;P, a::T

E

→c

DR[R~ i:=a], P, T E DR, k~ App(i, j);P, TE

→c

DR[R~ k:= !Ri·!Rj], P, TE Under the assumption that #⁻¹(!Ri)6→c(i.e., it is in final state).

DR, j~ Pred(i);P, T E

→c

(DR[R~ j:= !Ri 1, P, TE

, if !Ri∈N,

err, otherwise.

DR, j~ Succ(i);P, T E→c

(DR[R~ j:= !Ri⊕1, P, T E

, if !Ri∈N,

err, otherwise.

DR, l~ Test(i, j, k);P, TE

→c











DR[R~ l:= !Rj], P, T E

, if !Ri= 0, DR[R~ l:= !Rk], P, TE

, if !Ri∈N⁺,

err, otherwise.

Under the assumption that #⁻¹(!Ri)→cA(i.e., it is not in final state).

DR, j~ Pred(i);P, T E

→c

DR[R~ i:= #A], j Pred(i);P, T E DR, j~ Succ(i);P, TE

→c

DR[R~ i:= #A], j Succ(i);P, TE DR, l~ Test(i, j, k);P, T

E→c

DR[R~ i:= #A], l Test(i, j, k);P, T E

Fig. 3.Small-step operational semantics for extended addressing machines.

Definition 8. We introduce a fresh constanterr∈ M/ _Ato represent a machine raising an error.

1. Define a reduction strategy→con EAMs, representing one step of computation, as the least relation→c ⊆ M_A×(M_A∪ {err})closed under the rules in Figure 3.

2. Themultistep reduction^cis defined as the transitive-reflexive closure of→c. 3. Given M,N,M^cN, we write|M^c N| ∈ Nfor the length of the shortest

reduction path fromM toN.

4. For M,N ∈ M_A, we write M ↔c N if they have a common reduct Z ∈ M_A∪ {err}, i.e.M^cZcN.

5. An extended address machineM:is in final stateif it cannot reduce, written M6→c; reaches a final state if M^c M⁰ for some M⁰ ∈ M_A in final state;

raises an errorif M^cerr; does not terminate, otherwise.

As the redexes in Figure 3 are not overlapping, the confluence of^c follows easily (cf. [9, Lemma 2.11(2)]).

Lemma 3. If M^cM⁰, thenM@ #N ^cM⁰@ #N. Proof. By induction on the length ofM^cM⁰.

(11)

Example 6. See Example 5 for the definition of Succ1,Succ2,Add aux.

1. We have Succ1@ [0] c1 andSucc2@ [1] c3.

2. DefineAdd=Y₀@ [#Add aux] , an EAM performing the addition. We show:

Add@ [1,3]

→c

*(R0=aY₀, R1= #Add aux),0 App(0,1);

1 App(1,0);Call1,[1,3]

+

c

*R,~ Load0;Load 1;Load2; 3 Pred(1),4 Succ(2),0 App(0, 3), 0 App(0,4),0 Test(1, 2,0),Call0,[#Add,1,3]

+

^c

*R0= #Add, R1= 1, R2= 3, R3, R4,3 Pred(1),4 Succ(2), 0 App(0, 3),0 App(0,4),0 Test(1,2, 0),Call 0,[]

+

^c

*R0= #(Add@ [0,4] ), R1= 1, R2= 3, R3= 0, R4= 4, 0 Test(1,2,0),Call0,[]

+

^c

*R₀= #(Add@ [0,5] ), R₁= 0, R₂= 4, R₃= 0, R₄= 5, 0 Test(1,2,0),Call0,[]

+ ^c4 3. ForI=

R₀=∅,Load0;Call 0,[]

,Y0@ [#I] ^cI@ [#(Y0@ [#I] )] . 4. Y_n@ [#M, d₁, . . . , d_n] cM@ [d₁, . . . , d_n,#(Y_n@ [#M, d₁, . . . , d_n] )],for all

n≥0,M∈ M_A,d~∈A

3 Typing algorithm

Recall that the set T of (simple) types has been introduced in Definition 3(1).

We now show that certain extended addressing machines can typed, and that typable machines do not raise error during their execution.

Definition 9. 1. A typing context ∆ is a finite set of associations between registers and types, represented as a listRi₁ :α1, . . . , Ri_n :αn. The indices i1, . . . , in are not necessarily consecutive.

2. We denote by∆[Ri:α] the typing context∆where the type associated with R_i becomes α. If R_i is not present in∆, then∆[R_i:α] =∆, R_i:α.

3. Let ∆ be a typing context, M∈ M_A,P be a program, T ∈ T_A and α∈T. We define the typing judgements

∆`M:α ∆(P, T) :α

by mutual induction as the least relations closed under the rules of Figure 4.

The rules(nat) and (fix) are the base cases and they take precedence over (R_∅)and(R_T).

4. ForRi₁, . . . , Ri_n ∈R, write~ Ri₁:βi₁, . . . , Ri_n:βi_n|=R~ whenever

#⁻¹(!Rj) :βj, for allj∈ {i1, . . . , in}.

The algorithm in Figure 4 deserves some discussion. As it is presented as a set of inference rules, one should reason bottom-up. To give a machineMa typeα, one needs to derive the judgement`M:α. The machinesnandYn, recognizable

(12)

#M∈N

`M:int nat

#M=aY_n ~δ=δ1→ · · · →δn

`M: (~δ→α→α)→~δ→α fixn

∆(P, T) :α

∆` (), P, T

:α R₍₎

∆`

R0, . . . , Rr−1, P, T

:α !Rr=∅

∆`

(R0, . . . , Rr), P, T

:α R_∅

Rr:β, ∆`

R0, . . . , Rr−1, P, T

:α `#⁻¹(!Rr) :β

∆`

(R0, . . . , Rr), P, T

:α R_T

∆[Ri:β](P,[]) :α

∆(Loadi;P,[]) :β→α load_∅

∆[Ri:β](P, T) :α #⁻¹(a) :β

∆(Loadi;P, a::T) :α load_T

∆[Rj:int], Ri:int(P, T) :α

∆, Ri:int(j Pred(i);P, T) :α pred

∆[Rj:int], Ri:int(P, T) :α

∆, Ri:int(j Succ(i);P, T) :α succ (∆, Ri:int, Rj:β, Rk:β)[Rl:β](P, T) :α

∆, Ri:int, Rj:β, Rk:β(l Test(i, j, k);P, T) :α test

∆[Rk:β], Ri:α→β, Rj:α(P, T) :∆

∆, Ri:α→β, Rj:α(k App(i, j);P, T) :∆ app

`M1:α1 · · · `Mn:αn

∆, Ri:α1→ · · · →αn→α(Calli,[#M1, . . . ,#Mn]) :α call Fig. 4.Typing rules for extended addressing machines.

from their addresses, are special cases as they represent numerals and a recursion operator, respectively. A type can be associated with these machines without inspecting their structure, which explains why the rules (nat) and (fix) have higher precedence. Otherwise, the rule (R_T) allows to check whether the value in a register is typable and only retain its type, the rule (R_∅) allows to get rid of uninitialized registers. Once this initial step is performed, one needs to derive a judgement of the form Ri₁ : βi₁, . . . , Ri_n :βi_n (P, T) :α, where P and T are the program and the input tape of the original machine respectively. This is done by verifying the coherence of the instructions in the program with the types of the registers and of the values in the input tape.

As a final consideration, notice that the rules in Figure 4 can only be considered as an algorithm when the address table map is effectively given. Otherwise, the algorithm would depend on an oracle decidinga= #M.

Remark 2. 1. For allM∈ M_A andα∈T, we have`M:αif and only if there existsa∈Asuch that both #⁻¹(a) :αand #M=ahold.

2. If #M∈/ N∪ {a_Y_n|n≥0}, then we have`M:αif and only if there exists

∆such that∆|=M. ~R and∆(M.P,M.T) :α.

(13)

Example 7. The following typing judgements are derivable.

1. `Succ2:int→int

2. `Add:int→int→int, where Add=Y₀@ [#Add aux]

3. For a smaller example, like `Succ1 : int →int, we can provide the whole derivation tree:

R0:int

Call 0,[]

:int call R0:int

0 Succ(0);Call0,[]

:int succ

Load 0; 0 Succ(0);Call0,[]

:int→int load_∅

`

(),Load 0; 0 Succ(0);Call 0,[]

:int→int R₍₎

!R0=∅

`

(R₀=∅),Load0; 0 Succ(0);Call0,[]

:int→int R_∅ Lemma 4. Let M∈ M_A,α∈T. Assume that# :M→Ais effectively given.

1. IfM=R~ =∅, P,[]

then the typing algorithm is capable of deciding whether

`M:αholds.

2. In general, the typing algorithm semi-decides whether`M:αholds.

Proof. (Sketch) (i) In this case, ` M : α holds if and only if (M.P,[]) does.

By induction on the length of M.P, one verifies if it is possible to construct a derivation. Otherwise, conclude that`M:αis not derivable.

(ii) In the rules (R_T) and (LoadT), one needs to show that a type for the premises exists. As the set of types is countable, and effectively given, one can easily design an algorithm constructing a derivation tree (by dovetailing). How- ever, the algorithm cannot terminate when executed onM0from Remark 1.

The machineM0 from Remark 1 cannot be typable because it would require an infinite derivation tree.

Proposition 1. Let M,M⁰,N,∈ M_Aandα, β∈T. 1. If`M:β→αand`N:β then `M@ [#N] :α.

2. If`M:αandM→cNthen`N:α.

3. If`M:αthenM does not raise an error.

4. If`M:intthen either Mdoes not terminate or M^cn, for somen≥0.

Proof. (i) Simultaneously, one proves that∆(P, T) :β →αand`N:βimply

∆ (P, T@ [#N] ) : α. Proceed by induction on a derivation of ` M : β →α (resp.∆(P, T) :β→α).

Case (nat) is vacuous.

Case (fixn). We show the case forn= 0, the others being similar. By definition ofY0, we have:

Y0@ [#N] =

(∅, aY₀),Load 0; 1 App(1,0); 0 App(0, 1);Call0,[#N]

.

(14)

Notice that, in this case,β=α→α. Using #⁻¹(a_Y₀) =Y₀, we derive:

R0:α, R1:α(Call0,[]) :α

R0:α→α, R1:α(0 App(0,1);Call0,[]) :α app R0:α→α, R1: (α→α)→α(1 App(1,0);· · ·,[]) :α app

`N:α→α R1: (α→α)→α(Load0;· · ·,[#N]) :α `Y0: (α→α)→α load_T

`

(R0 =∅, R1=aY0),Load0; 1 App(1,0); 0 App(0,1);Call0,[#N]

:α R∗

Case load_∅. Then P =Load i;P⁰,T = [] and∆[R_i :β](P⁰,[]) :αholds.

By assumption`N:β, so we conclude∆(Loadi;P⁰,[]) :αby applying load_T. All other cases derive straightforwardly from the induction hypothesis.

(ii) The casesM=Y_norM=nfor somen∈Nare vacuous, as these machines are in final state. Otherwise, by Remark 2(2), we get ∆ (M.P,M.T) :α for some ∆|=M. ~R. By cases on the shape ofM.P.

CaseP =Loadi;P⁰. ThenM.T =a::T⁰otherwiseMwould be in final state, and N=R[R~ _i:=a], P⁰, T⁰

. From (Load_T) we get∆[Ri :β](P⁰, T⁰) :αfor some β∈Tsatisfying #⁻¹(a) :β. As∆|=R~ we derive ∆[Ri :β]|=R[R~ i :=a], therefore this case follows from the induction hypothesis.

CaseP =Calli;P⁰. ThenRi :α1→ · · · →αn →α,T = [#M1, . . . ,#Mn] and `Mj :αj, for all j≤n. In this case, we haveN= #⁻¹(!(M.Ri)) @T with

`#⁻¹(!(M.Ri)) :α1→ · · · →αn→α, so we conclude by (i).

All other cases follows easily from the induction hypothesis.

(iii) The three cases from Figure 4 where a machine can raise an error are ruled out by the typing rules (pred), (succ) and (test), respectively. Therefore, no error can be raised during the execution.

(iv) Assume that`M:intandMcNfor someNin final state. By (ii), we obtain that`N:intholds, thereforeN=nsince numerals are the only machines in final state typable with int.

4 Translation and simulation

We define a type-preserving translation from EPCFterms to extended addressing machines. More precisely, we show that if Γ `M : αis derivable then M is transformed into a machineM which is typable with the sameα. By Propo- sition 1,Mnever raises a runtime error and well–typedness is preserved during its execution. We then show that if a well-typed EPCFprogramM computes a value n, then its translation M reduces to the corresponding EAM n. Finally, this result is transported toPCFusing their equivalence on programs of typeint.

We start by showing that EAMs implementing the mainPCFinstructions are definable. We do not need any machinery for representing explicit substitutions because they are naturally modelled by the evaluation strategy of EAMs.

Lemma 5. Letn≥0. There are EAMs satisfying (for alla, b, c, d1, . . . , dn∈A):

1. Projⁿ_i @ [d₁, . . . , d_n] cd_i, for 1≤i≤n;

2. Apply_n@ [a, b, d1, . . . , dn] ^c#⁻¹(a) @ [d1, . . . , dn, b·d1· · ·dn];

(15)

3. Pred_n@ [a, d₁, . . . , d_n] c

R0=a·d1· · ·dn, ~R,; 0 Pred(0);Call0,[]

; 4. Succ_n@ [a, d₁, . . . , d_n] c

R₀=a·d₁· · ·d_n, ~R,; 0 Succ(0);Call 0,[]

; 5. Ifzn@ [a, b, c, d1, . . . , dn] ^c

*R0=a·d, R~ 1=b·d, R~ 2=c·d, ~~ R, 0 Test(0,1,2);Call 0,[]

+

;

Proof. Easy. As an example, we give a possible definition of the predecessor:

Predn=

*R₀, . . . , R_n,Load0;· · ·;Loadn; 0 App(0,1);· · ·; 0 App(0, n); 0 Pred(0);Call0,[]

+

The others are similar.

Lemma 6. The EAMs in the previous lemma can be defined in order to ensure their typability (for alln≥0,α, β, γ, δ_i∈T):

1. `Projⁿ_i :~δ→δi, with~δ=δ1→ · · · →δn; 2. `Apply_n: (~δ→β→α)→(~δ→β)→~δ→α;

3. `Predn: (~δ→int)→~δ→int;

4. `Succ_n: (~δ→int)→~δ→int;

5. `Ifzn: (~δ→int)→(~δ→α)→(~δ→α)→~δ→α;

Proof. Easy. The naive implementations are, in fact, typable.

Using the auxiliary EAMs given above, we can translate any EPCF term proceeding as follows. Intuitively, an EPCF term M having x₁, . . . , x_n as free variables is translated as an EAMMloadingnarguments as input.

Definition 10. (Translation) LetM be anEPCFterm, whose free variables are among~x=x₁, . . . , x_n. ThetranslationofM (w.r.t.~x) is a machineJMK

~ x∈ M_A defined by structural induction onM as follows:

Lσ+ [y←(τ, N)], MM

~

x=Lσ, MM

y,~x@ [#Lτ, NM] ; L[ ], MM

~x =JMK

~ x; JxiK

~

x =Projⁿ_i,

Jλy.MhσiK

~

x =Lσ, MM

~

x,y, where wlog y /∈~x;

JM ·NK

~

x =Apply_n@ [#JMK

~ x,#JNK

~ x] ; JkK

~

x =Projⁿ⁺¹₁ @ [k], where k∈N; JpredMK

~

x =Predn@ [#JMK

~ x] ; JsuccMK

~x =Succn@ [#JMK

~ x] ; Jifz(L, M, N)K

~

x =Ifzn@ [#JLK

~ x,#JMK

~ x,#JNK

~ x] ; JfixMK

~x =Y_n@ [#JMK

~ x].

We show the extended abstract machines associated by this translation to some of our running examples.

(16)

Example 8. 1. J(λx.succ(x)hi)·0K=Succ₁@ [#Proj¹₁,0] . 2. J(λsn.s(sn))(λx.succ(x))K=

Apply₂@ [#Proj²₁,#(Apply₂@ [#Proj²₁,#Proj²₂] ),#(Succ1@ [#Proj¹₁] )]. 3. JaddK=Y0@ #Jλf xy.ifz(y, x,(f·(succx)·(predy)))K

=Y0@ #Jifz(y, x,(f·(succx)·(predy)))K

f,x,y,

=Y0@ #(Ifz3@ [#Proj³₃,#Proj³₂,#Jf ·(succx)·(predy)K

f,x,y] ), whereJf·(succx)·(predy)K

f,x,y=

Apply₃@ [#(Apply₃@ [#Proj³₁,#(Succ3@ [#Proj³₂] )] ),#(Pred3@ [#Proj³₃] )]

Theorem 1. Let M be an EPCFterm,α∈T,Γ =x1:β1, . . . , xn:βn. Then Γ `M :α ⇒ `JMK

x1,...,xn :β1→ · · · →βn→α.

Proof. By induction on a derivation ofΓ `M :α. As an induction loading, one needs to prove simultaneously that for all explicit substitutionsσwith dom(σ) = {x1, . . . , x_n}, ifσ|=x₁:β₁, . . . , x_n :β_n then `Lσ(x_i)M:β_i, for alli≤n.

Theorem 2. Let M be an EPCFterm and V ∈Val. Then σ . M ⇓dV ⇒Lσ, MM↔cJVK Proof. By induction on a derivation ofσ . M ⇓dV.

Corollary 1. For an EPCFprogramM of type`M :int we have [ ]. M⇓d n⇒JMK^cn

Proof. Assume [ ]. M ⇓d n. By Theorem 2, we have L[ ], MM ↔c JnK. Since JnKcnand the numeral machinenis in final state we concludeJMKcn.

4.1 Applying the translation to regular PCF

We now show how to apply our machinery to the usualPCF: we writeP, Q for its terms,U for its values,`^PCF for its type system, and P ⇓U for its big-step (call-by-name) operational semantics. For the precise rules, we refer to [15] (or the technical appendix). Recall that any PCF program P can be seen as an EPCFterm, thanks to the notation λx.N :=λx.Nhi. However, the hypotheses P `^PCFP :int and P ⇓ n area priori not sufficient for applying Corollary 1, since one needs to show that also the correspondingEPCFjudgments `P :int andP ⇓_dnhold. The former is established by the following lemma.

Lemma 7. Let M be a PCFterm, α∈TandΓ be a context. Then Γ `^PCFM :α ⇒ Γ `M :α

Proof. By a straightforward induction on a derivation ofΓ `^PCFM.

(17)

An EPCF term is easily translated into PCF by performing all its explicit substitutions. The converse is trickier as the representation is not unique: for every PCFtermP there are several decompositionsP =P⁰[Q₁/x₁, . . . , Q_n/x_n].

Definition 11. 1. LetM be anEPCFterm and σbe an explicit substitution.

(a) The sizes|−|ofσ,M and(σ, M)are defined by mutual induction, e.g.

|[]|= 0, |ρ[x←(ρ⁰, N)]|=|ρ|+|(ρ⁰, N)|,

|(σ, M)|=|σ|+|M|, |λx.Mhσi|=|σ, M|+ 1,

and the other cases of|M|are standard whence they are omitted.

(b) Define a PCFterm (σ, M)^∗ by induction on|(σ, M)|as follows:

(σ, x)^∗=

(σ(x)^∗, ifx∈dom(σ), x, otherwise,

(σ, λx.Mhρi)^∗=λx.(σ+ρ, M)^∗, (σ, M·N)^∗= (σ, M)^∗·(σ, N)^∗, (σ,0)^∗= 0, (σ,predM)^∗=pred(σ, M)^∗, (σ,fixM)^∗=fix((σ, M)^∗), (σ,succM)^∗ =succ(σ, M)^∗, (σ,ifz(L, M, N))^∗=ifz((σ, L)^∗,(σ, M)^∗,(σ, N)^∗).

2. Given aPCFterm P, defineP^†={(σ, M)|(σ, M)^∗=P}.

Theorem 3. The big-step weak reduction of EPCF is equivalent to the usual big-step operational semantics ofPCF. (See the technical appendix.)

1. Given an EPCFprogram M, value V and an explicit substitution σ:

σ . M ⇓dV ⇒(σ, M)^∗⇓([ ], V)^∗ 2. Given aPCFprogram P andPCFvalueU:

P ⇓U ⇒ ∀(σ, M)∈P^†,∃V ∈Val.(σ . M ⇓dV and([ ], V)∈U^† ) Proof. 1. First show (σ+ [x←(ρ, N)], M)^∗= (σ, M)^∗[(ρ, N)^∗/x] by structural induction onM. Then proceed by induction on a derivation ofσ . M ⇓dV.

2. By induction on the lexicographically ordered pairs, whose first component is the length of a derivation ofP ⇓U and second component is|(σ, M)|. In fact, if M = y and σ(y) = (ρ, N), with (ρ, N) ∈ P^†, the length of the derivation (ρ, N)^∗⇓U remains unchanged, while|(ρ, N)|<|(σ, M)|. Then the case follows from the induction hypothesis by applying (var).

Case P ⇓ U since P = U = λx.P0. Since (σ, M) ∈ P^†, we have M = λx.M0hρiwithP0= (σ+ρ, M0)^∗. SettingV =λx.M0hσ+ρiwe obtainM ⇓dV by (fun) with ([], V)^∗=λx.(σ+ρ, M0) =λx.P0=U.

CaseP ⇓U sinceP =U =n. Analogous, but simpler.

All other cases follow easily from the induction hypothesis onP ⇓U. As promised, we now draw conclusions for the regularPCF. As customary in PCF, we are interested on the properties of closed terms having ground type.

Theorem 4. For aPCFprogramP of typeint,P ⇓nentails JPK^cn.

Proof. Note thatPis also anEPCFterm such that ([], P)∈P^†, and that`P :int by Lemma 7. Thus [ ]. P ⇓dnby Theorem 3(2). Conclude by Corollary 1.

(18)

5 Conclusions and future works

The Full Abstraction (FA) Problem forPCF, originally proposed by Robin Milner in [14] (see also [16,5,6]), can be informally formulated as the problem of finding a

“natural” model of PCF which is fully abstract w.r.t. the operational semantics.

More precisely, two programs sharing the type αget the same denotation in a FA model if and only if they are observationally indistinguishable when plugged in the same contextC[] of typeα→int. In the same paper, Milner proves that a fully abstract model can be obtained by a suitable completion of the “term model” construction, and that this model is unique up to isomorphism (under some natural conditions). The question is therefore whether it is possible to obtain this model using a direct “semantic” construction.

However, quoting from [3],

“the problem is to understand what should be meant by a semantic characterization [. . . ] Our view is that the essential content of the problem, what makes it important, is that it calls for a semantic characterization of sequential, functional computation at higher-types”.

A celebrated result is that fully abstract models of PCF can be obtained by constructing suitable categories of games [4,3,11].

We believe that the formalism of extended addressing machines introduced in this paper may contribute to the understanding of what can be considered as a sequential higher-order computation. Indeed, EAMs are certainly sequential computational devices and higher-order computations are simply achieved by passing the address of a machine having a functional behaviour. An objection that could be raised is that EAMs essentially incorporate the contents of the rewriting rules defining the operational semantics, whence they can be seen as a representation ofPCFoperational semantics in disguise. We believe that this kind of criticism is due to an oversimplistic view. For instance, the fundamental difference in the way one handles variables and registers assignments in typing contexts shows that some machines can be hardly seen as representing subterms of the originalPCFprogram. Another essential difference lies in the semantics of the recursion operator, which is achieved in the operational semantics through a (hidden) self-application, and in Scott-continuous models by computing the least fixed point of a continuous function. In the EAMs formalism the application mechanism is managed via a suitable assignment of addresses which by no means can be considered implicit in the operational semantics. Indeed the address table map is an arbitrary bijective function, constrained to some abstract conditions.

As it is easy to show, there exist adequate address table maps having arbitrary computational complexity. With this mechanism in place, the semantics of the fixed point operator is obtained by specifying a suitable EAM having its own address stored inside. In future works we plan to examine whether EAMs can be turned into a FA model of PCFby quotienting the setM_A w.r.t. a suitable observational equivalence.

(19)

References

1. Abadi, M., Cardelli, L., Curien, P.L., L´evy, J.J.: Explicit substitutions. In: Allen, F.E. (ed.) Conference Record of the Seventeenth Annual ACM Symposium on Principles of Programming Languages, San Francisco, California, USA, January 1990. pp. 31–46. ACM Press (1990). https://doi.org/10.1145/96709.96712,https:

//doi.org/10.1145/96709.96712

2. Abadi, M., Cardelli, L., Curien, P.L., L´evy, J.J.: Explicit substitutions. J. Funct.

Program. 1(4), 375–416 (1991). https://doi.org/10.1017/S0956796800000186, https://doi.org/10.1017/S0956796800000186

3. Abramsky, S., Jagadeesan, R., Malacaria, P.: Full abstraction for PCF. Inf.

Comput.163(2), 409–470 (2000). https://doi.org/10.1006/inco.2000.2930,https:

//doi.org/10.1006/inco.2000.2930

4. Abramsky, S., Malacaria, P., Jagadeesan, R.: Full abstraction for PCF.

In: Hagiya, M., Mitchell, J.C. (eds.) Theoretical Aspects of Computer Software, International Conference TACS ’94, Sendai, Japan, April 19-22, 1994, Proceedings. Lecture Notes in Computer Science, vol. 789, pp. 1–15.

Springer (1994). https://doi.org/10.1007/3-540-57887-0 87,https://doi.org/10.

1007/3-540-57887-0_87

5. Berry, G., Curien, P.L., L´evy, J.J.: Full abstraction for sequential languages: state of the art. In: Nivat, M., Reynolds, J. (eds.) Algebraic methods in semantics, pp.

89–132. Cambridge University Press (1985)

6. Curien, P.L.: Observable algorithms on concrete data structures. In: Proceedings of the Seventh Annual Symposium on Logic in Computer Science (LICS ’92), Santa Cruz, California, USA, June 22-25, 1992. pp. 432–443. IEEE Computer Society (1992). https://doi.org/10.1109/LICS.1992.185554,https://doi.org/10.

1109/LICS.1992.185554

7. Curien, P.L., Hardin, T., L´evy, J.J.: Confluence properties of weak and strong calculi of explicit substitutions. J. ACM 43(2), 362–397 (1996).

https://doi.org/10.1145/226643.226675, https://doi.org/10.1145/226643.

226675

8. Della Penna, G.: Una semantica operazionale per il network computing: le macchine di Turing virtuali. Master’s thesis, Universit`a degli Studi di L’Aquila (1996-97), in Italian

9. Della Penna, G., Intrigila, B., Manzonetto, G.: Addressing machines as models of λ-calculus. CoRRabs/2107.00319(2021),https://arxiv.org/abs/2107.00319 10. Fairbairn, J., Wray, S.: Tim: A simple, lazy abstract machine to execute supercombinators. In: Kahn, G. (ed.) Functional Programming Languages and Computer Architecture. pp. 34–45. Springer Berlin Heidelberg, Berlin, Heidelberg (1987) 11. Hyland, J.M.E., Ong, C.L.: On full abstraction for PCF: I, II, and III. Inf.

Comput.163(2), 285–408 (2000). https://doi.org/10.1006/inco.2000.2917,https:

//doi.org/10.1006/inco.2000.2917

12. L´evy, J.J., Maranget, L.: Explicit substitutions and programming languages. In:

Rangan, C.P., Raman, V., Ramanujam, R. (eds.) Foundations of Software Tech- nology and Theoretical Computer Science, 19th Conference, Chennai, India, De- cember 13-15, 1999, Proceedings. Lecture Notes in Computer Science, vol. 1738, pp. 181–200. Springer (1999). https://doi.org/10.1007/3-540-46691-6 14, https:

//doi.org/10.1007/3-540-46691-6_14

13. Longley, J.: Realizability toposes and language semantics. Ph.D. thesis, University of Edinburgh (1995)

(20)

14. Milner, R.: Fully abstract models of typed lambda-calculi. Theor. Comput. Sci.

4(1), 1–22 (1977). https://doi.org/10.1016/0304-3975(77)90053-6, https://doi.

org/10.1016/0304-3975(77)90053-6

15. Ong, C.H.L.: Correspondence between operational and denotational semantics of PCF. In: Abramsky, S., Gabbay, D., Maibaum, T.S.E. (eds.) Handbook of Logic in Computer Science, vol. 4, pp. 269–356. Oxford University Press (1995) 16. Plotkin, G.D.: LCF considered as a programming language. Theor. Comput.

Sci.5(3), 223–255 (1977). https://doi.org/10.1016/0304-3975(77)90044-5, https:

//doi.org/10.1016/0304-3975(77)90044-5

17. Seaman, J., Iyer, S.P.: An operational semantics of sharing in lazy evaluation. Sci. Comput. Program.27(3), 289–322 (1996). https://doi.org/10.1016/0167- 6423(96)00012-3,https://doi.org/10.1016/0167-6423(96)00012-3

(21)

U ∈Val

U ⇓U (val) P⇓n+ 1

predP⇓n (pr) P ⇓0

predP ⇓0 (pr0) P⇓0 Q⇓U1

ifz(P, Q, Q⁰)⇓U1

(ifz0) P ⇓n+ 1 Q⁰⇓U2

ifz(P, Q, Q⁰)⇓U2

(ifz>0) P⇓n

succP⇓n+ 1 (sc) P·(fixP)⇓U

fixP ⇓U (fix) P ⇓λx.P⁰ P⁰[Q/x]⇓U P·Q⇓U (βv)

Fig. 5.The big-step operational semantics ofPCF.

Γ, x:α`x:α

Γ, x:α`P :β Γ `λx.P :α→β

Γ `P :α→β Γ `Q:α Γ `P Q:β Γ `0 :int

Γ `P:int Γ `pred P :int

Γ `P:int Γ `succ P:int Γ `P:int Γ `Q:α Γ `Q⁰:α

Γ `ifz(P, Q, Q⁰) :α

Γ `P :α→α Γ `fixP :α Fig. 6.The type inference rules ofPCF.

A Technical Appendix

This appendix is devoted to recall the languagePCF, which is given for granted in the paper, as well as providing some missing proofs.

A.1 The standardPCF

We describe the syntax ofPCFterms, their typing system based on simple types and provide the associated (call-by-name) big-step operational semantics.

Our presentation ofPCFmainly follows [15].

Definition 12. 1. PCFtermsare defined by the grammar (forn≥0,x∈Var):

P, Q, Q⁰::= x|P·Q|λx.P

3. APCFvalue U is a term of the formλx.P or n, for somen≥0.

4. Given a PCFterm P and a value U, we write P ⇓U if this judgement can be obtained by applying the rules from Figure 5.

5. The setTof simple typesand typing contexts have already been defined in items (1)and (2)of Definition 3, respectively.

6. Given aPCFterm P, a typing context Γ andα∈T, we writeΓ `^PCFP :α if this typing judgement is derivable from the rules of Figure 6.

(22)

A.2 Proofs of Section 1

Proof of Lemma 1. Items (1) and (2) are straightforward. We prove (3).

Given anEPCFtermM, anEPCFvalueV, an explicit substitutionσ, a type α, and a context Γ such that σ . M ⇓d V, σ |= Γ, Γ ` M : α, we prove by induction on a derivation ofσ . M⇓dV that`V :α.

Case (nat): In this case M =V =n, for n ∈N, and α= int. By the typing rules ofEPCF,`n:int.

Case (fun): In this case M = λx.M⁰hρi, V = λx.M⁰hσ+ρi, α = β → γ. As Γ ` λx.M⁰hρi : β → γ, ∃!∆ such that ρ |= ∆, Γ, ∆, x : β ` M⁰ : γ. As σ |= Γ and ρ |= ∆, σ+ρ |= Γ, ∆. Thus by the typing rules of EPCF,

`λx.M⁰hσ+ρi:β→γ.

Case (var): In this caseM =x, σ(x) = (ρ, N), Γ =Γ⁰, x:α. By the operational semantics of EPCF, ρ . N ⇓_d V, and by the type system of EPCFas σ |= Γ⁰, x:α, [x←(ρ, N)]|=x:αand thusρ|=∆, ∆`N:α. By IH, `V :α.

Case (β_v): In this case M = N ·L. By the operational semantics of EPCF, σ . N ⇓d λx.N⁰hρiand ρ+ [x←(σ, L)]. N⁰ ⇓d V. By the type system of EPCF,Γ `N :β →α,Γ `L:β. By IH,`λx.N⁰hρi:β →α, and then by the type system ofEPCFρ|=∆, ∆, x: β `N⁰ :α. By the type system we also have [x←(σ, L)]|=x:β, soρ+ [x←(σ, L)]|=∆, x:β, and thus by induction hypothesis we conclude`V :α.

All other cases derive straightforwardly from applying the rules of the type system and the induction hypothesis.

A.3 Proofs of Section 4

Proof of Theorem 1. We prove the following statements by mutual induction and call the respective inductive hypotheses IH1 and IH2.

(i) LetM be an EPCFterm,Γ =x1:β1, . . . , xn:βn andα∈T. Then Γ `M :α ⇒ `JMK

x1,...,xn:β1→ · · · →βn→α.

(ii) For allΓ =x1:β1, . . . , xn:βn andσ, with dom(σ) ={x1, . . . , xn}, we have σ|=Γ ⇒ `Lσ(x₁)M:β₁, . . . ,`Lσ(x_n)M:β_n.

We start with the cases concerning (i).

Case (ax): Then, x1 : β1, . . . , xn : βn ` xi : βi, and JxiK

x1,...,xn = Projⁿ_i. By Lemma 6(1) we conclude`Projⁿ_i :β1→ · · · →βn →βi.

Case (0): In this case, we haveΓ `0:intandJ0K

x1,...,xn =Projⁿ⁺¹₁ @ [0] . By Lemma 6(1) ` Projⁿ⁺¹₁ @ : int→ β1 → · · · → βn →int and, by Figure 4

`#⁻¹(0) :int. By Proposition 1(1),`Projⁿ⁺¹₁ @ [0] :β1→ · · · →βn→int.