The Least Must Speak with the Greatest


 Laura Henderson
 2 years ago
 Views:
Transcription
1 The Least Must Speak with the Greatest J. Garrett Morris, Sam Lindley, and Philip Wadler The University of Edinburgh Abstract. We extend a propositionsastypes correspondence between linear logic and session types to include recursive sessions. Our extension takes least and greatest fixed points as dual, an idea wellknown to theorists, but which has not previously appeared in the treatment of recursive sessions. We preserve the freedom from races, deadlock, and livelock that is a hallmark of the propositionsastypes approach, and avoid a problem with preservation of duality that appears in the standard treatment of recursive session types. We treat two systems, one based on classical linear logic, derived from work of Caires and Pfenning and of Wadler, and one based on a linear functional language, derived from work of Gay and Vasconcelos. Our treatment of recursion is inspired by Baelde. 1 Introduction Previous work on session types suffers from a mismatch. Session types capture communication protocols. The two ends of a channel must be dual, which ensures that when one end of a channel performs output the other performs input, and when one end offers a choice of actions the other selects from these alternatives. Session types are of limited use without recursion, which permits defining sessions of arbitrary size. Recursion traditionally comes in two dual forms, least fixed point and greatest fixed point. However, in previous work on session types recursion is introduced in such a way that both ends of a channel are treated as least fixed points, a mismatch with the treatment of the other connectives. Here, we introduce a notion of recursion for session types that restores the traditional notion that least fixed points are dual to greatest fixed points. Honda (1993) introduced session types as a type system for process calculi, and Gay and Vasconcelos (2010) reformulated session types in the context of a functional language with linear types. Caires and Pfenning (2010) uncovered a propositionsastypes correspondence between session types and intuitionistic linear logic, and Wadler (2012) adapted the correspondence to classical linear logic. Wadler defines two systems, a process calculus CP (inspired by Caires and Pfenning) and a linear functional language GV (inspired by Gay and Vasconcelos), and presents a typepreserving translation from GV to CP. Subsequently, Lindley and Morris (2014) extended GV to support translation in the other direction, giving typepreserving translations not only from GV to CP but also from CP to GV. A hallmark of the propositionsastypes approach is that it yields systems guaranteed free of races and deadlock; both CP and GV benefit from these properties. Toninho et al. (2013, 2014) also treat recursion in systems inspired by a propositionsastypes correspondence, but they have no notion of duality for least and greatest fixed points.
2 There is much previous work that supports recursive session types, starting with Honda et al. (1998), and including Yoshida and Vasconcelos (2007) and Demangeon and Honda (2011), all of which suffer from the mismatch mentioned above. Here, drawing on work of Baelde (2012), we extend both CP and GV with recursive session types, taking least and greatest fixed points as duals. We show that the typepreserving translations extend to the new systems, and that the new systems are still guaranteed free of races, deadlock, and livelock. Bono and Padovani (2012) and Bernardi and Hennessy (2013) independently observed that the standard treatment of recursive session types fails to preserve duality in the case that the recursive variable appears within a carried type. Their solution relies on an unusual form of substitution that applies only to the carried types within a session type, while ours avoids the problem while using only standard forms of substitution. This paper makes the following contributions. Section 2 extends GV to support recursion, yielding µgv; and demonstrates its power with a series of examples of streams and a calculator. In µgv, unlike in previous session type systems, least fixed points are dual to greatest fixed points and duality is preserved in all cases. Section 3 extends CP to support recursion, yielding µcp, and presents a translation of some of the same examples. We show µcp is guaranteed free of races, deadlock, and livelock. Section 4 presents typepreserving translations from µgv into µcp and inversely. The translation guarantees that GV also is free of races, deadlock, and livelock. As a technical aid, we also present a typepreserving translation from µgv into a subset of itself, similar to one in Lindley and Morris (2014), showing how function and product types can be represented by session types. Section 5 surveys related work and Section 6 concludes. 2 A SessionTyped Functional Language In this section, we present µgv, a simple functional language with session types patterned on the language of Gay and Vasconcelos (2010) (which we call LAST) and Wadler s language GV. Throughout the paper we highlight the novel parts of µgv and µcp by shading them in gray. 2.1 Types Types in µgv are given by the following grammar: Types T, U, V ::= S T U T U T U Session Types S ::=!T.S?T.S end! end? {l i : S i} i {l i : S i} i S S X X µg νg Type Operators G ::= X.S The types comprise session types, linear pairs (T U ), and both linear (T U ) and unlimited (T U ) functions. Session types include input (?T.S), output
3 (!T.S), selection ( {l i : S i } i ), choice ( {l i : S i } i ), and closed channels (end? and end! ). There are two variations on the closed channel (end? ) and (end! ); these arise from our interpretation of session types in classical linear logic, where there is no selfdual proposition corresponding to closed channels. We include a notion of replicated sessions, corresponding to exponentials in linear logic: a channel of type S is a service, offering any number of channels of type S; a channel of type S is the server providing such channels. For simplicity, we omit polymorphism as it is an orthogonal concern. We include session variables (X ) and their duals (X ), and types corresponding to bounded recursion (µx.s) and unbounded corecursion (νx.s). If G is an operator X.S, then G(S ) denotes the standard captureavoiding substitution of S for X in S, which we write as S[S /X ]. Each type T is either linear (lin(t )) or unlimited (un(t )). All types are linear except unlimited functions T U, replicated channels S, and closed input channels end?. We extend the standard notion of duality to recursive and corecursive session types:!t.s =?T.S?T.S =!T.S end? = end! end! = end? {l i : S i} i = {l i : S i} i {l i : S i} i = {l i : S i} i S = S S = S µg = νg νg = µg where X = X and we define the dual of an operator G = X.S as G = X.G(X ). Observe that G(S) = G(S). Unlike many notions of duality for session types, our definition preserves duality when recursive session types are unrolled, even when the recursion occurs in the carried types. For example, consider the operator G = X.?X.end?, its dual G = X.!X.end!, and the dual session types µg and νg. Unrolling µg yields G(µG) =?µg.end? ; unrolling νg yields G(νG) =!νg.end! =!µg.end!, which is the dual of?µg.end?. To ensure that fixed points exist, we require that all operators X.S be monotonic, that is, X may appear only in positive subformulas of S. Thus, the operator X.!X.end! is not monotonic, but the operator X.!(X end! ).end! is. Formally, X.S is monotonic iff the predicate pos X,S holds, where pos and neg are defined by the homomorphic extensions of the following equations: pos X,X = true pos X,X = false pos X,!T.S = neg X,T pos X,S pos X,T U = neg X,T pos X,U pos X,T U = neg X,T pos X,U neg X,X = false neg X,X = true neg X,!T.S = pos X,T neg X,S neg X,T U = pos X,T neg X,U neg X,T U = pos X,T neg X,U 2.2 Typing Rules We let Φ range over type environments. The judgement Φ M : T states that term M has type T in type environment Φ. Figure 1 gives the typing rules of µgv. The structural rules account for variables, and for weakening and contraction of unlimited types. The rules for the functional terms are standard; note that, to account for linearity, the context is split in the rules for application and pair introduction and elimination, and is restricted to unlimited types in the introduction of unlimited arrows.
4 Structural Rules un(t U ) un( S) un(end? ) x : T x : T Lambda Rules Φ M : U un(t ) Φ, x : T M : U Φ, x : T, x : T M : U un(t ) Φ, x : T M [x/x ] : U Φ, x : T M : U Φ λx.m : T U Φ M : T U Φ, Ψ M N : U Ψ N : T Φ M : T U Φ M : T U un(φ) Φ M : T U Φ M : T U Session Rules Φ M : T Ψ N : U Φ, Ψ (M, N ) : T U Φ M : T U Ψ, x : T, y : U N : V Φ, Ψ let (x, y) = M in N : V Φ M : S Ψ N : S Φ M : T Ψ N :!T.S Φ, Ψ link M N : end! Φ, Ψ send M N : S Φ M :?T.S Φ receive M : T S Φ, x : S M : end! Φ fork x.m : S Φ M : {l i : S i } i Φ M : {l i : S i } i Ψ, x : S i N i : T Φ select l i M : S i Φ, Ψ case M {l i x.n i } i : T Φ M : S Φ request M : S Φ M : µg Φ M : G(µG) Φ, x : S M : end! un(φ) Φ serve x.m : S f : X T end!, c : G(X ), x : T M : end! cofix f c x = M : νg T end! Admissible Session Rules Φ M : G(µG) Φ M : µg Φ M : νg Φ M : G(νG) Φ M : G(νG) Φ M : νg Fig. 1: Typing Rules for µgv The typing of input, output, choice and selection are those of Gay and Vasconcelos (2010). Following our earlier work (Lindley and Morris, 2014), the term link M N implements channel forwarding. The fork construct provides session initiation. The rule for serve x.m parallels that for fork: it defines a server which replicates M, and returns the channel by which it may be used (of type S = S). The novelty of µgv is in its recursive and corecursive channels; we attempt to remain close to existing presentations of recursive session types (Honda et al., 1998). The construct cofix f c x = M is used to define corecursive sessions. We provide for the rolling and unrolling of fixed points µg and νg, implementing the equivalences among equirecursive types. As we observe in Section 4.3, only the first of these coercion rules is essential. The remaining rules are admissible, albeit at the cost of introducing additional computation. The remainder of the section presents several examples illustrating the use of cofix. In addition, we have implemented a prototype of µgv plus various extensions, and we have implemented many examples, including all of those of Toninho et al. (2013). All of the code is available at the following URL: https://github.com/jgbm/cpgv.
5 2.3 Streams We will write letx = M inn for (λx.m )N and assume an extension of µgv with a type of naturals (Nat), literals (0, 1,... ), addition (+), and multiplication ( ). A canonical example of a corecursive data type is a stream. Let us consider a session type for producing a stream of naturals. Source = νx. {next :!Nat.X, stop : end! } A channel of type Source can either produce the next number or stop. The dual of a source is a sink. Sink = µx. {next :?Nat.X, stop : end? } Using cofix we can define a function that sends a stream of zeros along a corecursive channel: Zeros : Source end! Zeros = cofix f c = case c {next c.let c = send 0 c in f c; stop c.c} If the next number is chosen, then a zero is sent along the channel and we recurse. Otherwise we stop. We define a helper macro to read the next value from a stream: and now: GetNext : Sink Nat Sink GetNext c = receive (select next c) let c = fork c.zeros c in let (x, c) = GetNext c in let (y, c) = GetNext c in let (z, c) = GetNext c in let c = select stop c in (x, (y, z)) begins by forking a stream of zeros, and then reads from the corresponding sink several times, returning (0, (0, 0)). Productivity. We might expect to assign c the type {next :!Nat.Source, stop : end! } and f the type Source end! in the body of Zeros, but then productivity would not be assured and deadlock would be possible. For example, under those typing assumptions, the following would also be welltyped: cofix f c = f c We restrict the typing rule for cofix in order to guarantee productivity. We use a fresh type variable X to abstract the recursive behavior, so the channel c has type G(X ) (in our example {next :!Nat.X, stop : end! }) instead of G(νG), and f has type X end! instead of νg end!. The body of cofix is thus required to provide exactly one step of the corecursive behavior.
6 Coinvariants. We allow recursive sessions to maintain internal state (a coinvariant). In the cofix typing rule this is captured by the additional arguments x. For example, we can construct a stream of consecutive naturals: Nats : Source end! Nats = cofix nats c x = case c {next c. let c = send x c in nats c (x + 1) stop c. c} The variable x tracks the next value to send to the stream, and is accordingly incremented in the recursive call. Now, the following: let c = fork c.nats c 0 1 in let (x, c) = GetNext c in let (y, c) = GetNext c in let (z, c) = GetNext c in let c = select stop c in (x, (y, z)) returns (0, (1, 2)). We can maintain coinvariants of arbitrary complexity; for example, we can define a stream of the Fibonacci numbers as follows: Fibs : Source end! Fibs = cofix fibs c m n = case c {next c.let c = send m c in fibs c n (m + n) stop c. c} 2.4 Multifunction Calculator We now define a basic multifunction calculator. We aim to implement a process that accepts a stream of addition and multiplication requests, and can at any time provide the accumulated result: Calc = νx. {add :?Nat.X, mul :?Nat.X, result :!Nat.X, stop : end! }. We implement a provider of calculator functionality as follows: MakeCalc : Calc Nat end! MakeCalc = cofix calc c accum = case c of {add c. let (x, c) = receive c in calc c (accum + x) mul c. let (x, c) = receive c in calc c (accum x) result c. let c = send accum c in calc c accum stop c. c} Here is an example of using a calculator: let c = fork c.makecalc c 0 in let c = send 6 (select add c) in let c = send 7 (select mul c) in let (x, c) = receive (select result c) in let c = select stop c in x We begin by constructing an instance of the calculator with the accumulator starting at 0. We perform several calculations, adding 6 to the accumulator and multiplying by 7. Finally, we obtain the result (42) and close the channel.
7 P Γ, y : A Q, y : A x w x : A, w : A new y (P Q) Γ, x[].0 x : 1 P Γ, y : A, x : B x(y).p Γ, x : A B P Γ, y : A Q, x : B x[y].(p Q) Γ,, x : A B P Γ x().p Γ, x : P Γ, x : A i P Γ, x : A Q Γ, x : B x[in i].p Γ, x : A 1 A 2 case x {P; Q} Γ, x : A B case x {} Γ, x : P Γ P Γ, x :?A P y : A,?Γ!x(y).P Γ, x :!A P y : A, Γ?x[y].P Γ, x :?A P Γ, x : F (µf ) rec x.p Γ, x : µf P x :?A, x :?A, Γ P[x/x ] Γ, x :?A P Γ, y : A Q y : A, x : F (A) corec F x y (P, Q) Γ, x : νf Fig. 2: Typing Rules for µcp 3 A Linear LogicBased Process Calculus The types of µcp are the propositions of classical linear logic, extended with type operators F and fixed points µf, νf. Types A, B ::= A B A B 1 A B A B 0?A!A X X µf νf Type Operators F ::= X.A If F = X.A, define F (B) = A[B/X ]. The standard notion of classical linear logic duality is extended to fixed points in the expected fashion: (A B) = A B 1 = (A B) = A B = 1 (!A) =?A (?A) =!A (A B) = A B = 0 (A B) = A B 0 = (νf ) = µf (µf ) = νf where X = X, and we define the dual of a type operator by F = X.(F (X )). Similarly to µgv, (F (A)) = F (A ). We let Γ, range over type environments. The judgement P Γ states that process P uses channels Γ. Typing rules for µcp terms are given in Fig. 2. We write fv(p) for the free variables used in process P; in the typing rules, new bound variables are designated y. Structural Rules. µcp has two structural rules, axiom and cut. We interpret the axiom x w as channel forwarding: actions on channel x are mirrored on w, and vice versa. Thus, x and w must have dual type. Cut new y (P Q) is interpreted as communication between processes P and Q on channel y; the duality of the typing of y assures that its uses in P and Q are compatible. We identify µcp up to structural equivalence: x w w x new y (P Q) new y (Q P) new y (P new z (Q R)) new z (new y (P Q) R), if y fv(r)
8 Input and Output. The multiplicative connectives and are interpreted as input and output. The process x(y).p inputs channel y on channel x, and continues as P. The process x[y].(p Q) is interpreted as bound output: it sends a fresh variable y along x, spawns a process P in which y is used, and continues as process Q in which x is used. It amounts to the πcalculus term (νy)x(y).(p Q). We write x[y].p as syntactic sugar for x[y ].(y y P). The units of and, and 1, are interpreted as nullary input and nullary output, respectively. Selection and Choice. The additive connectives and are interpreted as selection and choice. The process case x {P 1 ; P 2 } offers a choice of processes P 1 and P 2 ; dually, the process x[in i ].P i chooses the ith alternative. The unit for choice is 0, indicating absurdity. Note that there is no term proving 0. The dual of absurdity is, and provides arbitrary behavior; as there is no term proving 0, no term relying on can reduce. Replication and Dereliction. The exponential connectives! and? in linear logic provide restricted access to the classical rules of weakening and contraction. We interpret them as serving (!) and requesting (?) replicated processes. For a server channel of type!a, the process P proving A may be replicated arbitrarily, so each channel that P uses must be replicable as well. We write?γ to assert that all types in Γ be of the form?b. As well as the introduction rule for a request channel of type?a, there are also implicit rules for weakening and contraction. Recursion and Corecursion. We introduce least fixed points µf and greatest fixed points νf to CP, following Baelde s (2012) proof theoretic treatment of fixed points in linear logic. The proof rules can be understood from traditional twosided rules for least and greatest fixed points, combined with the duality between the fixed points. We begin with a twosided presentation: F (A) A Γ, A B Γ, µf B Γ F (µf ) Γ µf Γ, F (νf ) B Γ, νf B A F (A) Γ A Γ νf Functional programmers may recognize the first as the rule for a fold, and the fourth as the rule for an unfold. We adapt the above rules to a one sided presentation as follows. (As Γ denotes any context, we write Γ instead of Γ ). F (A ), A Γ, A, B Γ, νf, B Γ, F (µf ) Γ, µf Γ, F (µf ), B Γ, µf, B A, F (A) Γ, A Γ, νf However, now we can observe that Γ, B is itself an instance of a context, and F a type operator, and so the topright rule is just an instance of the bottomleft rule, and the topleft rule is just an instance of the bottomright rule. The bottom two
9 new x (w x P) = P[w/x] new x (x[y].(p Q) x(y).r) = new y (Q new x (P R)) new x (x[].0 x().p) Γ = P new x (x[in i].p case x {Q 1; Q 2}) = new x (P Q i) new x (!x(y).p?x[y].q) = new y (P Q) new y (!x(y).p Q) = Q, x / fv(q) new x (!x(y).p Q[x/x ]) = new x (!x(y).p new x (!x (y).p Q)) new x (corec F x y (P, Q) rec x.r) = new y (P new x (Q new x (Q R[x /x]))) where Q = map F x,x (corecf x y (x y, Q[x /x])) Fig. 3: Principal Cut Elimination Rules map X.C x,y (P) = x y, if X is not free in C map X.X x,y (P) = P map X.C 1 C 2 x,y (P) = x(x ).y[y ].(map X.C 1 x,y (P[x /x, y /y]) map X.C 2 x,y (P)) map X.C 1 C 2 x,y (P) = case x {y[in 1].map X.C 1 x,y (P); y[in 2].map X.C 2 x,y (P)} map X.?C x,y (P) =!x(x ).?y[y ].P[x /x, y /y] map X.µF x,y (P) = corec F x y (y y, rec y.map X.F (µf ) x,y (P[y /y])) Fig. 4: Definition of map for Positive Combinators rules are the typing rules for the µcp terms rec x.p and corec F x y (P, Q). We will often omit the F annotation. As in µgv, corec terms maintain a coinvariant y, of type A. The coinvariant can be seen as being sent from P to Q; thus, its type is dual in P and Q. As carried types are not dual in µgv, no corresponding duality appears in the typing rule for cofix. 3.1 Cut Elimination Cut elimination corresponds to synchronous process reduction. The principal cut reductions are given in Fig. 3. The majority of these are standard; for instance, cut reduction of against corresponds to picking one of the offered alternatives. Cut reduction for fixed points corresponds to unrolling one iteration from the corec term, directed by the type of the fixed point operator F. It depends on a proof construction known as functoriality, which derives the following proof rule for any type operator F : A, B F (A), F (B) We call the term implementing this construction map by analogy with a similar construct in functional programming. The positive cases of map are given in Fig. 4; the remaining cases are obtained by exchanging channels x and y. Lemma 1. If P x : A, y : B then map F x,y(p) x : F (A), y : F (B). The commuting conversions push communication under process prefixes, and are given in Fig. 5. The standard meta theoretic properties of classical linear
10 new z (x[y].(p Q) R) = x[y].(new z (P R) Q), if z fv(q) new z (x[y].(p Q) R) = x[y].(p new z (Q R)), if z fv(p) new z (x(y).p Q) = x(y).new z (P Q) new z (x[in i].p Q) = x[in i].new z (P Q) new z (case x {P; Q} R) = case x {new z (P R); new z (Q R)} new z (?x[y].p Q) =?x[y].new z (P Q) new z (!x(y).p Q) =!x(y).new z (P Q) new z (rec x.p Q) = rec x.new z (P Q) new z (corec x y (P, Q) R) = corec x y (new z (P R), Q) Fig. 5: Commuting Conversions logic with fixed points apply directly to µcp. Therefore deadlock and livelock freedom follow directly from cut elimination, and race freedom follows directly from confluence. 3.2 Streams As we did for µgv, we assume that our language is extended with constants implementing unlimited natural numbers (we could implement Nat within µcp, but choose not to due to lack of space). In particular, assume there exists a proposition Nat, such that Nat is subject to contraction and weakening, and terms: Zero x x : Nat Inc y,x y : Nat, x : Nat We can now use fixed points in µcp to encode streams of naturals. Source = νx. {next : Nat X, stop : 1} Sink = µx. {next : Nat X, stop : } We can define a process which generates a stream of zeros. In this example, we make no use of the coinvariant, and so assign it the type 1: Zeros y y : Source Zeros y = corec y z (z[].0, z().case y {next : y[x].(zero x y[].0); stop : y[].0}). Now we define a process which generates a stream of naturals. As in the corresponding µgv example, we use the coinvariant represent the next number in the stream. Nats y y : Source Nats y = cofix y z (Zero z, case y {next : y[x].(z x new w (Inc z,w w y)) stop : y[].0}) In the next case, we rely on contraction to copy the coinvariant z. We then send one copy along the channel y and increment the other giving w, which we use to reestablish the coinvariant. In the stop case, we rely on weakening for Nat to dispose of the coinvariant. The following receives the first three numbers from the stream of naturals and sends them on z; thus, z has type Nat (Nat Nat ). new y (Nats y rec y.y[next].y(a).rec y.y[next].y(b).rec y.y[next].y(c). rec y.y[stop].y().z[a].z[b].z c)
11 (λx.m ) = fork z.let (x, z) = receive z in link (M ) z (L M ) = send (M ) (L) (M, N ) = fork z.link (send (M ) z) (N ) (let (x, y) = M in N ) = let (x, y) = receive (M ) in (N ) (L : T U ) = serve z.link (L) z (L : T U ) = request (L) (receive M ) = (M ) (cofix f c x = M ) = cofix p c z = let f = λ c x.send x (send c (request p)) in let x = z in (M ) Fig. 6: Translation of µgv Terms to µgvπ 4 Relating µgv and µcp In our previous work (Lindley and Morris, 2014) we give translations between CP and HGV, an extension of GV, corresponding to µgv without recursive session types. In this section, we extend these translations to incorporate recursion. 4.1 Translation from µgv to µgvπ Following our previous work, we factor the translation of µgv into µcp through an intermediate translation. The language µgvπ is the restriction of µgv to session types; that is, µgv without,, or. In order to avoid, we permit receive M, only fused with a pair elimination let (x, y) = receive M in N. We can simulate all nonsession types as session types via a translation from µgv to µgvπ. The translation on types is given by the homomorphic extension of the following equations: (T U ) =!(T ).(U ) (T U ) = (!(T ).(U ) ) (T U ) =?(T ).(U ) Each target type is the interface to the simulated source type. A linear function is simulated by input on a channel; its interface is output on the other end of the channel. An unlimited function is simulated by a server; its interface is the service on the other end of that channel. A tensor is simulated by output on a channel; its interface is input on the other end of that channel. This duality between implementation and interface explains the dualization of types in Wadler s original CPS translation from GV to CP. To translate away the arrows in the cofix rule, we adopt a simplified sessionoriented variant of cofix for µgvπ: p : (!X.!T.end! ), c : G(X ), x : T M : end! Φ cofix p c x = M : (!νg.!t.end! ) This rule takes advantage of the translation of functions given by ( ), and simulates multiple arguments using. The translation on terms is given by the homomorphic extension of the equations in Fig. 6. Formally, this is a translation from derivations to terms. We write type annotations to indicate introduction and elimination. The only new case is that for corec. We collect the arguments into a tuple, and simulate the interface
12 Φ, x : end? N : S z = x(). Φ N : S z Φ, x : end? N [x/x ] : S z = new x ( Φ, x : end?, x : end? N : S z x [].0) x z = x z fork x.m z = new x (new y ( M y y[].0) x z) link M N z = z().new x ( M x N x) send M N z = new x (x[y].( M y x z) N x) let (x, y) = receive M in M z = new y ( M y y(x). N z) select l M z = new x ( M x x[l].x z) case M {l i x.n i} i z = new x ( M x case x {l i. N i z} i) request M z = new x ( M x?x[y].y z) serve y.m z =!z(y).new x ( M x x[].0) Φ M : G(µG) z = new y ( Φ M : µg y rec y.y z) cofix p c x = M z =!z(y).y(c).y(w).y().corec c x (x w, new p (!p(y).y(c).y(w).y().c w new y ( M y y[].0))) Φ M : µg z = new y ( Φ M : G(µG) y corec z x (y x, map G z,x (rec x.x z))) Φ M : G(νG) z = new y ( Φ M : νg y corec y x (y x, map G z,x (rec x.x z))) Φ M : νg = new y ( Φ M : G(νG) y rec z.y z) Fig. 7: Translation of µgvπ Terms into µcp to the arrows using session operations as in the rest of the ( ) translation. We use the obvious encodings for nary let binding, lambdas, and send. We write (Φ) for the pointwise extension of (T ). Theorem 2. If Φ M : T then (Φ) (M ) : (T ). 4.2 Translation from µgvπ to µcp We now give a translation from µgvπ to CP. Post composing this with the embedding of µgv in µgvπ yields a semantics for µgv. For uniformity, we assume the obvious encodings of nary,, and case in CP. The translation on session types is as follows:!t.s = T S?T.S = T S end! = 1 end? = {l i : S i} i = {l i : S i } i {l i : S i} i = {l i : S i } i S =? S S =! S X = X X = X νg = ν G µg = µ G X.S = X. S The translation is homomorphic except for output, where the argument type is dualized. This accounts for the discrepancy between!t.s =?T.S and (A B) = A B. The translation on terms (Fig. 7) is formally specified as a CPS translation on derivations as in Wadler s work. We abbreviate the derivation by its final judgement in the translations of weakening and contraction for end?, and for rolling and unrolling of recursive session types νg and µg, as these steps are implicit in the syntax of µgv terms, but explicit in µcp. The other
13 new x (P Q) = let x = fork x. P in Q x y = link x y x[y].(p Q) = let x = send (fork y. P ) x in Q x(y).p = let (y, x) = receive x in P x[].0 = x x().p = P x[l].p = let x = select l x in P case x {l i.p i} i = case x {l i. P i } i?s[x].p = let x = request s in P!s(x).P = link s (serve x. P ) rec x.p = P corec F c x (P, Q) = send c (send (fork x. P ) (request (cofix p c x = Q F,p,c,x ))) where Q F,p,c,x = let c = fork c. Q in map F c,c(?p[z].z[c].z[c ].z[].0) Fig. 8: Translation of µcp Terms into µgvπ constructs depend only on the immediate syntactic structure, so we abbreviate their translations as mappings on plain terms. The majority of translations are as in our previous work. The rolling and unrolling of fixed points in µgv can be translated to cuts against the µcp proofs of the corresponding equivalences. The translation of cofix is a corecursive process with coinvariant x in which p abstracts reestablishing the coinvariant at the end of each step. Theorem 3. If Φ M : T, then M z Φ, z : T. As we have already argued that µcp is deadlock and livelock free, and we now have that all µgv terms correspond to µcp derivations, we can also conclude that µgv is deadlock and livelock free. Note that the type environment Φ is not dual in the result of the translation. This reflects the different interpretations of types in µcp and µgv: a µgv type!t.s designates a channel that expects output, whereas the µcp type T S designates a process that performs output. 4.3 Translating from µcp to µgvπ We now present the translation from µcp to µgvπ. On types: A B =! A. B A B =? A. B 1 = end! = end? +{l i : A i} i = +{l i : A i } i {l i : A i} i = {l i : A i } i?a = A!A = A X = X X = X νf = ν F µf = µ F X.A = X. A The translation on terms makes use of let expressions to simplify the presentation; these are expanded to µgvπ as follows: let x = M in N ((λx.n )M ) = send M (fork z.let (x, z) = receive z in link N z) The translation is given in Fig. 8. The interesting cases are for rec and corec. The translation of rec x.p relies on exactly one use of the rule that unrolls
14 µf to F (µf ) applied to the variable x. The translation of corec simulates the expansion of Q, using p to reestablish the coinvariant after each expansion, and thus depends on the translation of functoriality from µcp to µgv. Theorem 4. If P Γ, then Γ P : end!. As the semantics of µgv is defined by translation to µcp, the following soundness theorem tells us that µgv and µcp are equally expressive. Theorem 5. If P Γ then new z (z[].0 P z) = P. Remark. The admissibility of the final three rules of Fig. 1 follows from Theorem 5, as neither nor uses any of these rules. 5 Related Work Session types were originally introduced by Honda (1993), and were further extended by Takeuchi et al. (1994), Honda et al. (1998), and Yoshida and Vasconcelos (2007). The systems of Honda et al. (1998) and Yoshida and Vasconcelos (2007) include recursive session types. They do not distinguish between recursion and corecursion, and do not exhibit deadlock freedom. Bono and Padovani (2012) and Bernardi and Hennessy (2013) independently observed that duality in those systems was not preserved under unrolling of recursive types; Bernardi et al. (2014) studies the role of duality in session types, including those with recursion. This work adopts a different solution from ours, however, and we hope to investigate the consequences of these different approaches in future work. Caires and Pfenning (2010) showed the first complete propositionsastypes correspondence between intuitionistic linear logic (ILL) and session types. Their work shows both an interpretation of session types as ILL propositions, and a computational interpretation of ILL proofs as πcalculus processes. As a result, they are able to show that welltyped processes are free of races, deadlock, and livelock, by analogy with corresponding cutelimination results for ILL. Toninho et al. (2013) demonstrate an embedding of their calculus within a functional language; the resulting system admits unrestricted recursion in the functional setting, and can thus provide recursive communication behavior, but does not guarantee that the evaluation of function terms terminates. Girard (1987) speculated that linear logic would be wellsuited to reasoning about concurrency. Abramsky (1994) and Bellin and Scott (1994) explored the interpretation of linear logic proofs as concurrent programs. Kobayashi et al. (1996) introduced the use of linear typing to the πcalculus, and demonstrated a form of linear channels similar in usage to sessiontyped channels; Dardha et al. s (2012) extensions to this work include full session types. 6 Conclusion and Future Work We have demonstrated a propositionsastypes correspondence linking recursive session types and fixed points in linear logic. Unlike previous work on recursive
15 session types, our presentation distinguishes between recursive and corecursive processes. As a consequence of cut elimination in linear logic, all welltyped processes are free of races, deadlock, and livelock. We identify several areas of future work. We would like to give an asynchronous semantics to µgv, following the original presentation of LAST by Gay and Vasconcelos (2010), and show that it is equivalent to the synchronous semantics provided by cut elimination in µcp. We would like to extend µgv with recursive and corecursive types in general, and investigate whether we can extend the ( ) translation to simulate these types as recursive and corecursive session types. We would like to explore further extensions of µcp and their consequences for µgv, including: the addition of secondorder polymorphism, as studied by Wadler (2012) for CP and Lindley and Morris (2014) for GV; the addition of the MIX 0 and MIX 2 rules, providing additional notions of parallel composition and unifying the types end! and end? ; and identify natural extensions of CP that give rise to nondeterminism, and thus allow programs to exhibit more interesting concurrent behavior, while preserving the underlying connection to linear logic. References S. Abramsky. Proofs as processes. In Selected Papers of the Conference on Meeting on the Mathematical Foundations of Programming Semantics, Part I : Linear Logic: Linear Logic, MFPS 92, pages 5 9, Oxford, United Kingdom, Elsevier. D. Baelde. Least and greatest fixed points in linear logic. ACM Trans. Comput. Logic, 13(1): 2:1 2:44, Jan ISSN G. Bellin and P. J. Scott. On the πcalculus and linear logic. Theoretical Computer Science, 135 (1):11 65, G. Bernardi and M. Hennessy. Using higherorder contracts to model session types. CoRR, abs/ , G. Bernardi, O. Dardha, S. J. Gay, and D. Kouzapas. On duality relations for session types, Draft. V. Bono and L. Padovani. Typing copyless message passing. Logical Methods in Computer Science, 8(1), L. Caires and F. Pfenning. Session types as intuitionistic linear propositions. In International Conference on Concurrency Theory, CONCUR 10, pages , O. Dardha, E. Giachino, and D. Sangiorgi. Session types revisited. In PPDP, pages , R. Demangeon and K. Honda. Full abstraction in a subtyped πcalculus with linear types. In CONCUR, pages , S. J. Gay and V. T. Vasconcelos. Linear type theory for asynchronous session types. Journal of Functional Programming, 20(01):19 50, J.Y. Girard. Linear logic. Theoretical Computer Science, 50(1):1 101, Jan K. Honda. Types for dyadic interaction. In CONCUR, pages , K. Honda, V. T. Vasconcelos, and M. Kubo. Language primitives and type discipline for structured communicationbased programming. In ESOP, pages , N. Kobayashi, B. C. Pierce, and D. N. Turner. Linearity and the picalculus. In POPL, pages , S. Lindley and G. Morris. Sessions as propositions. In PLACES, K. Takeuchi, K. Honda, and M. Kubo. An interactionbased language and its typing system. In PARLE, pages , B. Toninho, L. Caires, and F. Pfenning. Higherorder processes, functions, and sessions: A monadic integration. In Proceedings of the 22nd European Conference on Programming Languages and Systems, ESOP 13, pages , Rome, Italy, SpringerVerlag. ISBN B. Toninho, L. Caires, and F. Pfenning. Corecursion in sessiontyped processes, Draft. P. Wadler. Propositions as sessions. In Proceedings of the 17th ACM SIGPLAN International Conference on Functional Programming, ICFP 12, pages ACM, N. Yoshida and V. T. Vasconcelos. Language primitives and type discipline for structured communicationbased programming revisited: Two systems for higherorder session communication. Electr. Notes Theor. Comput. Sci., 171(4):73 93, 2007.
Boolean Algebra Part 1
Boolean Algebra Part 1 Page 1 Boolean Algebra Objectives Understand Basic Boolean Algebra Relate Boolean Algebra to Logic Networks Prove Laws using Truth Tables Understand and Use First Basic Theorems
More informationParametric Domaintheoretic models of Linear Abadi & Plotkin Logic
Parametric Domaintheoretic models of Linear Abadi & Plotkin Logic Lars Birkedal Rasmus Ejlers Møgelberg Rasmus Lerchedahl Petersen IT University Technical Report Series TR007 ISSN 600 600 February 00
More informationLinear Types for Continuations
1/28 Linear Types for Continuations Alex Simpson LFCS, School of Informatics University of Edinburgh, UK Joint work with: Jeff Egger (LFCS, Edinburgh) Rasmus Møgelberg (ITU, Copenhagen) Linear Types for
More informationObservational Program Calculi and the Correctness of Translations
Observational Program Calculi and the Correctness of Translations Manfred SchmidtSchauss 1, David Sabel 1, Joachim Niehren 2, and Jan Schwinghammer 1 GoetheUniversity, Frankfurt, Germany 2 INRIA Lille,
More informationFoundational Proof Certificates
An application of proof theory to computer science INRIASaclay & LIX, École Polytechnique CUSO Winter School, Proof and Computation 30 January 2013 Can we standardize, communicate, and trust formal proofs?
More informationCHAPTER 7 GENERAL PROOF SYSTEMS
CHAPTER 7 GENERAL PROOF SYSTEMS 1 Introduction Proof systems are built to prove statements. They can be thought as an inference machine with special statements, called provable statements, or sometimes
More informationPredicate Logic Review
Predicate Logic Review UC Berkeley, Philosophy 142, Spring 2016 John MacFarlane 1 Grammar A term is an individual constant or a variable. An individual constant is a lowercase letter from the beginning
More information4 Domain Relational Calculus
4 Domain Relational Calculus We now present two relational calculi that we will compare to RA. First, what is the difference between an algebra and a calculus? The usual story is that the algebra RA is
More informationLinearly Used Effects: Monadic and CPS Transformations into the Linear Lambda Calculus
Linearly Used Effects: Monadic and CPS Transformations into the Linear Lambda Calculus Masahito Hasegawa Research Institute for Mathematical Sciences, Kyoto University hassei@kurimskyotouacjp Abstract
More informationTypes, Polymorphism, and Type Reconstruction
Types, Polymorphism, and Type Reconstruction Sources This material is based on the following sources: Pierce, B.C., Types and Programming Languages. MIT Press, 2002. Kanellakis, P.C., Mairson, H.G. and
More informationComputing divisors and common multiples of quasilinear ordinary differential equations
Computing divisors and common multiples of quasilinear ordinary differential equations Dima Grigoriev CNRS, Mathématiques, Université de Lille Villeneuve d Ascq, 59655, France Dmitry.Grigoryev@math.univlille1.fr
More informationSoftware Modeling and Verification
Software Modeling and Verification Alessandro Aldini DiSBeF  Sezione STI University of Urbino Carlo Bo Italy 34 February 2015 Algorithmic verification Correctness problem Is the software/hardware system
More informationSystem BV is NPcomplete
System BV is NPcomplete Ozan Kahramanoğulları 1,2 Computer Science Institute, University of Leipzig International Center for Computational Logic, TU Dresden Abstract System BV is an extension of multiplicative
More information1 if 1 x 0 1 if 0 x 1
Chapter 3 Continuity In this chapter we begin by defining the fundamental notion of continuity for real valued functions of a single real variable. When trying to decide whether a given function is or
More informationChapter 7: Functional Programming Languages
Chapter 7: Functional Programming Languages Aarne Ranta Slides for the book Implementing Programming Languages. An Introduction to Compilers and Interpreters, College Publications, 2012. Fun: a language
More informationQuotient Rings and Field Extensions
Chapter 5 Quotient Rings and Field Extensions In this chapter we describe a method for producing field extension of a given field. If F is a field, then a field extension is a field K that contains F.
More informationModal Proofs as Distributed Programs (Extended Abstract)
Modal Proofs as Distributed Programs (Extended Abstract) Limin Jia and David Walker Princeton University 35 Olden St., Princeton, NJ 08544, USA {ljia,dpw}@cs.princeton.edu Abstract. We develop a new foundation
More informationChapter 13: Basic ring theory
Chapter 3: Basic ring theory Matthew Macauley Department of Mathematical Sciences Clemson University http://www.math.clemson.edu/~macaule/ Math 42, Spring 24 M. Macauley (Clemson) Chapter 3: Basic ring
More informationA Propositional Dynamic Logic for CCS Programs
A Propositional Dynamic Logic for CCS Programs Mario R. F. Benevides and L. Menasché Schechter {mario,luis}@cos.ufrj.br Abstract This work presents a Propositional Dynamic Logic in which the programs are
More information(What I Know about) the History of the Identity Type
(What I Know about) the History of the Identity Type Peter Dybjer Chalmers University, Göteborg, Sweden Workshop on Identity Types Uppsala, 13 November, 2006 When was the identity type born? MartinLöf
More informationMATH 55: HOMEWORK #2 SOLUTIONS
MATH 55: HOMEWORK # SOLUTIONS ERIC PETERSON * 1. SECTION 1.5: NESTED QUANTIFIERS 1.1. Problem 1.5.8. Determine the truth value of each of these statements if the domain of each variable consists of all
More informationClassical BI. (A Logic for Reasoning about Dualising Resources) James Brotherston Cristiano Calcagno
Classical BI (A Logic for Reasoning about Dualising Resources) James Brotherston Cristiano Calcagno Dept. of Computing, Imperial College London, UK {jbrother,ccris}@doc.ic.ac.uk Abstract We show how to
More informationSummary Last Lecture. Automated Reasoning. Outline of the Lecture. Definition sequent calculus. Theorem (Normalisation and Strong Normalisation)
Summary Summary Last Lecture sequent calculus Automated Reasoning Georg Moser Institute of Computer Science @ UIBK Winter 013 (Normalisation and Strong Normalisation) let Π be a proof in minimal logic
More informationChapter 4, Arithmetic in F [x] Polynomial arithmetic and the division algorithm.
Chapter 4, Arithmetic in F [x] Polynomial arithmetic and the division algorithm. We begin by defining the ring of polynomials with coefficients in a ring R. After some preliminary results, we specialize
More informationProbabilità e Nondeterminismo nella teoria dei domini
Probabilità e Nondeterminismo nella teoria dei domini Daniele Varacca ENS, Paris BRICS, Aarhus Parma, 15 giugno 2004 Probabilità e Nondeterminismo nella teoria dei domini p.1 Road Map Motivation Domain
More information(LMCS, p. 317) V.1. First Order Logic. This is the most powerful, most expressive logic that we will examine.
(LMCS, p. 317) V.1 First Order Logic This is the most powerful, most expressive logic that we will examine. Our version of firstorder logic will use the following symbols: variables connectives (,,,,
More informationEncoding Mathematics in FirstOrder Logic
Applied Logic Lecture 19 CS 486 Spring 2005 Thursday, April 14, 2005 Encoding Mathematics in FirstOrder Logic Over the past few lectures, we have seen the syntax and the semantics of firstorder logic,
More informationRelations: their uses in programming and computational specifications
PEPS Relations, 15 December 2008 1/27 Relations: their uses in programming and computational specifications Dale Miller INRIA  Saclay & LIX, Ecole Polytechnique 1. Logic and computation Outline 2. Comparing
More informationThe Division Algorithm for Polynomials Handout Monday March 5, 2012
The Division Algorithm for Polynomials Handout Monday March 5, 0 Let F be a field (such as R, Q, C, or F p for some prime p. This will allow us to divide by any nonzero scalar. (For some of the following,
More informationDeterministic Discrete Modeling
Deterministic Discrete Modeling Formal Semantics of Firewalls in Isabelle/HOL Cornelius Diekmann, M.Sc. Dr. Heiko Niedermayer Prof. Dr.Ing. Georg Carle Lehrstuhl für Netzarchitekturen und Netzdienste
More informationYou know from calculus that functions play a fundamental role in mathematics.
CHPTER 12 Functions You know from calculus that functions play a fundamental role in mathematics. You likely view a function as a kind of formula that describes a relationship between two (or more) quantities.
More informationFunctional Programming. Functional Programming Languages. Chapter 14. Introduction
Functional Programming Languages Chapter 14 Introduction Functional programming paradigm History Features and concepts Examples: Lisp ML 1 2 Functional Programming Functional Programming Languages The
More informationChapter 7. Induction and Recursion. Part 1. Mathematical Induction
Chapter 7. Induction and Recursion Part 1. Mathematical Induction The principle of mathematical induction is this: to establish an infinite sequence of propositions P 1, P 2, P 3,..., P n,... (or, simply
More informationNotes 11: List Decoding Folded ReedSolomon Codes
Introduction to Coding Theory CMU: Spring 2010 Notes 11: List Decoding Folded ReedSolomon Codes April 2010 Lecturer: Venkatesan Guruswami Scribe: Venkatesan Guruswami At the end of the previous notes,
More information8 Divisibility and prime numbers
8 Divisibility and prime numbers 8.1 Divisibility In this short section we extend the concept of a multiple from the natural numbers to the integers. We also summarize several other terms that express
More informationThreshold Logic. 2.1 Networks of functions
2 Threshold Logic 2. Networks of functions We deal in this chapter with the simplest kind of computing units used to build artificial neural networks. These computing elements are a generalization of the
More informationBindings, mobility of bindings, and the quantifier
ICMS, 26 May 2007 1/17 Bindings, mobility of bindings, and the quantifier Dale Miller, INRIASaclay and LIX, École Polytechnique This talk is based on papers with Tiu in LICS2003 & ACM ToCL, and experience
More informationIntroduction to Algebraic Geometry. Bézout s Theorem and Inflection Points
Introduction to Algebraic Geometry Bézout s Theorem and Inflection Points 1. The resultant. Let K be a field. Then the polynomial ring K[x] is a unique factorisation domain (UFD). Another example of a
More informationThe Import & Export of Data from a Database
The Import & Export of Data from a Database Introduction The aim of these notes is to investigate a conceptually simple model for importing and exporting data into and out of an objectrelational database,
More information3. Predicates and Quantifiers
3. PREDICATES AND QUANTIFIERS 45 3. Predicates and Quantifiers 3.1. Predicates and Quantifiers. Definition 3.1.1. A predicate or propositional function is a description of the property (or properties)
More informationType Theory & Functional Programming
Type Theory & Functional Programming Simon Thompson Computing Laboratory, University of Kent March 1999 c Simon Thompson, 1999 Not to be reproduced i ii To my parents Preface Constructive Type theory has
More informationSECOND DERIVATIVE TEST FOR CONSTRAINED EXTREMA
SECOND DERIVATIVE TEST FOR CONSTRAINED EXTREMA This handout presents the second derivative test for a local extrema of a Lagrange multiplier problem. The Section 1 presents a geometric motivation for the
More informationSETS, RELATIONS, AND FUNCTIONS
September 27, 2009 and notations Common Universal Subset and Power Set Cardinality Operations A set is a collection or group of objects or elements or members (Cantor 1895). the collection of the four
More informationSeparation Properties for Locally Convex Cones
Journal of Convex Analysis Volume 9 (2002), No. 1, 301 307 Separation Properties for Locally Convex Cones Walter Roth Department of Mathematics, Universiti Brunei Darussalam, Gadong BE1410, Brunei Darussalam
More informationElementary Number Theory and Methods of Proof. CSE 215, Foundations of Computer Science Stony Brook University http://www.cs.stonybrook.
Elementary Number Theory and Methods of Proof CSE 215, Foundations of Computer Science Stony Brook University http://www.cs.stonybrook.edu/~cse215 1 Number theory Properties: 2 Properties of integers (whole
More informationSimulationBased Security with Inexhaustible Interactive Turing Machines
SimulationBased Security with Inexhaustible Interactive Turing Machines Ralf Küsters Institut für Informatik ChristianAlbrechtsUniversität zu Kiel 24098 Kiel, Germany kuesters@ti.informatik.unikiel.de
More informationSets and Logic. Chapter Sets
Chapter 2 Sets and Logic This chapter introduces sets. In it we study the structure on subsets of a set, operations on subsets, the relations of inclusion and equality on sets, and the close connection
More informationValidated Templates for Specification of Complex LTL Formulas
Validated Templates for Specification of Complex LTL Formulas Salamah Salamah Department of Electrical, computer, Software, and Systems Engineering Embry Riddle Aeronautical University 600 S. Clyde Morris
More informationMATH REVIEW KIT. Reproduced with permission of the Certified General Accountant Association of Canada.
MATH REVIEW KIT Reproduced with permission of the Certified General Accountant Association of Canada. Copyright 00 by the Certified General Accountant Association of Canada and the UBC Real Estate Division.
More informationRotation Matrices and Homogeneous Transformations
Rotation Matrices and Homogeneous Transformations A coordinate frame in an ndimensional space is defined by n mutually orthogonal unit vectors. In particular, for a twodimensional (2D) space, i.e., n
More informationCoeffects: Unified static analysis of contextdependence
Coeffects: Unified static analysis of contextdependence Tomas Petricek, Dominic Orchard and Alan Mycroft University of Cambridge, UK {tp322,dao29,am}@cl.cam.ac.uk Abstract. Monadic effect systems provide
More informationmax cx s.t. Ax c where the matrix A, cost vector c and right hand side b are given and x is a vector of variables. For this example we have x
Linear Programming Linear programming refers to problems stated as maximization or minimization of a linear function subject to constraints that are linear equalities and inequalities. Although the study
More informationLinear Algebra I. Ronald van Luijk, 2012
Linear Algebra I Ronald van Luijk, 2012 With many parts from Linear Algebra I by Michael Stoll, 2007 Contents 1. Vector spaces 3 1.1. Examples 3 1.2. Fields 4 1.3. The field of complex numbers. 6 1.4.
More informationNondeterministic Semantics and the Undecidability of Boolean BI
1 Nondeterministic Semantics and the Undecidability of Boolean BI DOMINIQUE LARCHEYWENDLING, LORIA CNRS, Nancy, France DIDIER GALMICHE, LORIA Université Henri Poincaré, Nancy, France We solve the open
More informationFoundations of Artificial Intelligence
Foundations of Artificial Intelligence 7. Propositional Logic Rational Thinking, Logic, Resolution Wolfram Burgard, Bernhard Nebel and Martin Riedmiller AlbertLudwigsUniversität Freiburg Contents 1 Agents
More informationImperial College London. Department of Computing
Imperial College London Department of Computing A Session Type Discipline for Event Driven Programming Models by Dimitrios Kouzapas Submitted in partial fulfilment of the requirements for the MSc Degree
More informationChapter 1. Logic and Proof
Chapter 1. Logic and Proof 1.1 Remark: A little over 100 years ago, it was found that some mathematical proofs contained paradoxes, and these paradoxes could be used to prove statements that were known
More informationIntroduction to type systems
Introduction to type systems p. 1/5 Introductory Course on Logic and Automata Theory Introduction to type systems Polyvios.Pratikakis@imag.fr Based on slides by Jeff Foster, UMD Introduction to type systems
More informationApplying Gauss elimination from boolean equation systems to simple integer equation systems
Applying Gauss elimination from boolean equation systems to simple integer equation systems Kevin van der Pol Eindhoven University of Technology January 19, 2012 Abstract We define a direct transformation
More informationAlgebra Unpacked Content For the new Common Core standards that will be effective in all North Carolina schools in the 201213 school year.
This document is designed to help North Carolina educators teach the Common Core (Standard Course of Study). NCDPI staff are continually updating and improving these tools to better serve teachers. Algebra
More informationDiscrete Mathematics, Chapter : Predicate Logic
Discrete Mathematics, Chapter 1.41.5: Predicate Logic Richard Mayr University of Edinburgh, UK Richard Mayr (University of Edinburgh, UK) Discrete Mathematics. Chapter 1.41.5 1 / 23 Outline 1 Predicates
More informationIt is time to prove some theorems. There are various strategies for doing
CHAPTER 4 Direct Proof It is time to prove some theorems. There are various strategies for doing this; we now examine the most straightforward approach, a technique called direct proof. As we begin, it
More informationDedekind s forgotten axiom and why we should teach it (and why we shouldn t teach mathematical induction in our calculus classes)
Dedekind s forgotten axiom and why we should teach it (and why we shouldn t teach mathematical induction in our calculus classes) by Jim Propp (UMass Lowell) March 14, 2010 1 / 29 Completeness Three common
More informationTheorem 5. The composition of any two symmetries in a point is a translation. More precisely, S B S A = T 2
Isometries. Congruence mappings as isometries. The notion of isometry is a general notion commonly accepted in mathematics. It means a mapping which preserves distances. The word metric is a synonym to
More informationPART I. THE REAL NUMBERS
PART I. THE REAL NUMBERS This material assumes that you are already familiar with the real number system and the representation of the real numbers as points on the real line. I.1. THE NATURAL NUMBERS
More informationEnvelope Theorem. Kevin Wainwright. Mar 22, 2004
Envelope Theorem Kevin Wainwright Mar 22, 2004 1 Maximum Value Functions A maximum (or minimum) value function is an objective function where the choice variables have been assigned their optimal values.
More information1.4/1.5 Predicates and Quantifiers
1.4/1.5 Predicates and Quantifiers Can we express the following statement in propositional logic? Every computer has a CPU No Outline: Predicates Quantifiers Domain of Predicate Translation: Natural Languauge
More informationType Classes with Functional Dependencies
Appears in Proceedings of the 9th European Symposium on Programming, ESOP 2000, Berlin, Germany, March 2000, SpringerVerlag LNCS 1782. Type Classes with Functional Dependencies Mark P. Jones Department
More informationUnderstanding Basic Calculus
Understanding Basic Calculus S.K. Chung Dedicated to all the people who have helped me in my life. i Preface This book is a revised and expanded version of the lecture notes for Basic Calculus and other
More information[Refer Slide Time: 05:10]
Principles of Programming Languages Prof: S. Arun Kumar Department of Computer Science and Engineering Indian Institute of Technology Delhi Lecture no 7 Lecture Title: Syntactic Classes Welcome to lecture
More informationHomework until Test #2
MATH31: Number Theory Homework until Test # Philipp BRAUN Section 3.1 page 43, 1. It has been conjectured that there are infinitely many primes of the form n. Exhibit five such primes. Solution. Five such
More informationCHAPTER 2. Inequalities
CHAPTER 2 Inequalities In this section we add the axioms describe the behavior of inequalities (the order axioms) to the list of axioms begun in Chapter 1. A thorough mastery of this section is essential
More informationResearch Note. Biintuitionistic Boolean Bunched Logic
UCL DEPARTMENT OF COMPUTER SCIENCE Research Note RN/14/06 Biintuitionistic Boolean Bunched Logic June, 2014 James Brotherston Dept. of Computer Science University College London Jules Villard Dept. of
More informationDiscrete Mathematics Lecture 3 Elementary Number Theory and Methods of Proof. Harper Langston New York University
Discrete Mathematics Lecture 3 Elementary Number Theory and Methods of Proof Harper Langston New York University Proof and Counterexample Discovery and proof Even and odd numbers number n from Z is called
More informationLogic and Incidence Geometry
Logic and Incidence Geometry February 27, 2013 1 Informal Logic Logic Rule 0. No unstated assumption may be used in a proof. 2 Theorems and Proofs If [hypothesis] then [conclusion]. LOGIC RULE 1. The following
More informationThe Mathematics of Origami
The Mathematics of Origami Sheri Yin June 3, 2009 1 Contents 1 Introduction 3 2 Some Basics in Abstract Algebra 4 2.1 Groups................................. 4 2.2 Ring..................................
More informationMathematics for Computer Science/Software Engineering. Notes for the course MSM1F3 Dr. R. A. Wilson
Mathematics for Computer Science/Software Engineering Notes for the course MSM1F3 Dr. R. A. Wilson October 1996 Chapter 1 Logic Lecture no. 1. We introduce the concept of a proposition, which is a statement
More informationNotes on Determinant
ENGG2012B Advanced Engineering Mathematics Notes on Determinant Lecturer: Kenneth Shum Lecture 918/02/2013 The determinant of a system of linear equations determines whether the solution is unique, without
More informationEMBEDDING COUNTABLE PARTIAL ORDERINGS IN THE DEGREES
EMBEDDING COUNTABLE PARTIAL ORDERINGS IN THE ENUMERATION DEGREES AND THE ωenumeration DEGREES MARIYA I. SOSKOVA AND IVAN N. SOSKOV 1. Introduction One of the most basic measures of the complexity of a
More informationLinear Codes. Chapter 3. 3.1 Basics
Chapter 3 Linear Codes In order to define codes that we can encode and decode efficiently, we add more structure to the codespace. We shall be mainly interested in linear codes. A linear code of length
More information2. Methods of Proof Types of Proofs. Suppose we wish to prove an implication p q. Here are some strategies we have available to try.
2. METHODS OF PROOF 69 2. Methods of Proof 2.1. Types of Proofs. Suppose we wish to prove an implication p q. Here are some strategies we have available to try. Trivial Proof: If we know q is true then
More informationCLASSICAL BI: ITS SEMANTICS AND PROOF THEORY
Logical Methods in Computer Science Vol. 6 (3:3) 2010, pp. 1 42 www.lmcsonline.org Submitted Aug. 1, 2009 Published Jul. 20, 2010 CLASSICAL BI: ITS SEMANTICS AND PROOF THEORY JAMES BROTHERSTON a AND CRISTIANO
More informationFunctional Optimization Models for Active Queue Management
Functional Optimization Models for Active Queue Management Yixin Chen Department of Computer Science and Engineering Washington University in St Louis 1 Brookings Drive St Louis, MO 63130, USA chen@cse.wustl.edu
More informationSOME SUPERINTUITIONISTIC LOGICS AS THE LOGICAL FRAGMENTS OF EQUATIONAL THEORIES 1
Tatsuya Shimura NobuYuki Suzuki SOME SUPERINTUITIONISTIC LOGICS AS THE LOGICAL FRAGMENTS OF EQUATIONAL THEORIES 1 Kripke frame semantics is used as a concise and convenient apparatus for the study of
More informationSets and functions. {x R : x > 0}.
Sets and functions 1 Sets The language of sets and functions pervades mathematics, and most of the important operations in mathematics turn out to be functions or to be expressible in terms of functions.
More informationA Framework for the Semantics of Behavioral Contracts
A Framework for the Semantics of Behavioral Contracts Ashley McNeile Metamaxim Ltd, 48 Brunswick Gardens, London W8 4AN, UK ashley.mcneile@metamaxim.com Abstract. Contracts have proved a powerful concept
More informationOn strong fairness in UNITY
On strong fairness in UNITY H.P.Gumm, D.Zhukov Fachbereich Mathematik und Informatik Philipps Universität Marburg {gumm,shukov}@mathematik.unimarburg.de Abstract. In [6] Tsay and Bagrodia present a correct
More informationParallel programming with Session Java
1/17 Parallel programming with Session Java Nicholas Ng (nickng@doc.ic.ac.uk) Imperial College London 2/17 Motivation Parallel designs are difficult, error prone (eg. MPI) Session types ensure communication
More informationSubsets of Euclidean domains possessing a unique division algorithm
Subsets of Euclidean domains possessing a unique division algorithm Andrew D. Lewis 2009/03/16 Abstract Subsets of a Euclidean domain are characterised with the following objectives: (1) ensuring uniqueness
More informationRINGS WITH A POLYNOMIAL IDENTITY
RINGS WITH A POLYNOMIAL IDENTITY IRVING KAPLANSKY 1. Introduction. In connection with his investigation of projective planes, M. Hall [2, Theorem 6.2]* proved the following theorem: a division ring D in
More informationRepresenting Reversible Cellular Automata with Reversible Block Cellular Automata
Discrete Mathematics and Theoretical Computer Science Proceedings AA (DMCCG), 2001, 145 154 Representing Reversible Cellular Automata with Reversible Block Cellular Automata Jérôme DurandLose Laboratoire
More informationAutomated Theorem Proving  summary of lecture 1
Automated Theorem Proving  summary of lecture 1 1 Introduction Automated Theorem Proving (ATP) deals with the development of computer programs that show that some statement is a logical consequence of
More informationProof: A logical argument establishing the truth of the theorem given the truth of the axioms and any previously proven theorems.
Math 232  Discrete Math 2.1 Direct Proofs and Counterexamples Notes Axiom: Proposition that is assumed to be true. Proof: A logical argument establishing the truth of the theorem given the truth of the
More informationMAT2400 Analysis I. A brief introduction to proofs, sets, and functions
MAT2400 Analysis I A brief introduction to proofs, sets, and functions In Analysis I there is a lot of manipulations with sets and functions. It is probably also the first course where you have to take
More informationHigherOrder Logic. Specification and Verification with HigherOrder Logic
HigherOrder Logic Specification and Verification with HigherOrder Logic Arnd PoetzschHeffter Software Technology Group Fachbereich Informatik Technische Universität Kaiserslautern Sommersemester 2010
More informationCHAPTER 5: MODULAR ARITHMETIC
CHAPTER 5: MODULAR ARITHMETIC LECTURE NOTES FOR MATH 378 (CSUSM, SPRING 2009). WAYNE AITKEN 1. Introduction In this chapter we will consider congruence modulo m, and explore the associated arithmetic called
More informationSemantics and Verification of Software
Semantics and Verification of Software Lecture 21: Nondeterminism and Parallelism IV (Equivalence of CCS Processes & WrapUp) Thomas Noll Lehrstuhl für Informatik 2 (Software Modeling and Verification)
More information(Refer Slide Time: 01:1101:27)
Digital Signal Processing Prof. S. C. Dutta Roy Department of Electrical Engineering Indian Institute of Technology, Delhi Lecture  6 Digital systems (contd.); inverse systems, stability, FIR and IIR,
More informationa = bq + r where 0 r < b.
Lecture 5: Euclid s algorithm Introduction The fundamental arithmetic operations are addition, subtraction, multiplication and division. But there is a fifth operation which I would argue is just as fundamental
More information4: SINGLEPERIOD MARKET MODELS
4: SINGLEPERIOD MARKET MODELS Ben Goldys and Marek Rutkowski School of Mathematics and Statistics University of Sydney Semester 2, 2015 B. Goldys and M. Rutkowski (USydney) Slides 4: SinglePeriod Market
More information