Transparent Synchronous Dataflow

Steven W.T. Cheunga, Dan R. Ghicaa, and Koko Muroyaa,b a University of Birmingham b RIMS, Kyoto University

Abstract Dataflow programming is a popular and convenient programming paradigm in systems modelling, optimisation, and machine learning. It has a number of advantages, for instance the lacks of control flow allows computation to be carried out in parallel as well as in distributed machines. More recently the idea of dataflow graphs has also been brought into the design of various deep learning frameworks. They facilitate an easy and efficient implementation of automatic differentiation, which is the heart of modern deep learning paradigm. Many dataflow languages are ‘modal’ in the sense that the dataflow graph is ‘constructed’ in an ambient environment then ‘executed’ using special commands. Simulink, earlier Tensorflow, Lucid Synchrone (LS) or Self-adjusting computation (SAC) are examples of such languages. We are interested in modal dataflow languages in which the ambient environment is a fully fledged functional and imperative language. Such ambient languages make creating complex and large models easier, but they raise questions of language design, safety and efficiency. LS provides a way to define dataflow graphs through co-recursive equations of streams. In these cases the interesting issue is efficiency, particularly of memory utilisation. A semantically interesting question occurs in the case of languages which allow the explicit manipulation of the dataflow graph using imperative constructs. This is the case of early Tensorflow and imperative SAC. However the meta-programming styleof TensorFlow in which special commands are used to construct imperatively a dataflow graph was considered awkward and error prone, and TensorFlow moved away from it. Constructing a dataflow graph imperatively can be convenient, but both Tensorflow and SAC are unsafe, in the sense that ‘illegal’ dataflow graphscan be constructed during the execution, which leads to unsafe behaviour. These problems can be avoided by a judicious language design. We present an idealised calculus for dataflow with both imperative and functional features using an abstract machine model based on Geometry of Interaction enhanced with rewriting features (‘Dynamic GoI’). Although the language is modal, with distinct executions for the PCF-like fragment and the DFG fragment, the syntax of the language is uniform. So the language lacks the “metaprogramming” feel of TensorFlow and other embedded DSL-like solutions. Concretely, any operator is used in the same way whether as a part of the host language or the DFG. This is akin to operator overloading, except that it is realised an a purely semantic way. Establishing a “semantic context”, defined by its history of execution, is as far as we know a novel approach which, as we shall see, will require a novel approach to semantics. We have also proved safety of the language and its in-principle efficiency. A prototype implementation of the calculus is also described, as a PPX extension of the OCaml programming language.

ACM CCS 2012 Theory of computation → Operational semantics; Keywords Semantics of programming languages, Dataflow computation, Geometry of Interaction, Synchronous computation

The Art, Science, and Engineering of Programming

Submitted June 21, 2020

Published February 28, 2021 doi 10.22152/programming-journal.org/2021/5/12

© Steven W.T. Cheung, Dan R. Ghica, and Koko Muroya This work is licensed under a “CC BY 4.0” license. In The Art, Science, and Engineering of Programming, vol. 5, no. 3, 2021, article 12; 55 pages. Transparent Synchronous Dataflow

1 Introduction

1.1 Background

Dataflow programming is a broad programming paradigm loosely based onthe principle that computation is organised as a graph in which data-changes to the inputs are propagated to the outputs in a more-or-less automatic manner. Notable examples include spreadsheets [51], system analysis and simulation [16], machine learning [1], embedded reactive systems [28], functional reactive programming (FRP) [18] and more. One of the attractive features of dataflow systems is that their native mode of operation lacks control flow, so it is inherently parallel. This makes issues suchas synchrony and (non)determinism pertinent. The parallelism of dataflow system is transparent, with much of the event-level manipulation hidden from the programmer, so ‘lower level’ issues such as deadlock are usually not a concern. Pure dataflow programming is convenient, but only suitable for particular applications. So it is more common to have dataflow-style idioms and libraries within general purpose programming. This is the case with FRP. The language design challenge is non- trivial. When the host language is used natively to construct the dataflow graph gross inefficiency can be a serious problem, particularly when streams of data must be merged, which leads to explosive memory requirements. This is unavoidable in monadic FRP, where the monad multiplication requires the merging of a stream of streams into a single stream. Different languages deal with this problems in different ways, for example by replacing monads with ‘arrows’ in FRP [37], by using temporal type systems [33], or by clocking each data stream in such a way that streams can be merged using fixed-size buffers [12]. Whereas dataflow functionality can be seamlessly integrated into a larger language (FRP for Haskell) ‘modal’ behaviour, consisting of a model-building mode and a model-execution mode remains popular for nich languages. Simulink [16], earlier Tensorflow [1], or Lucid Synchrone [40] are examples of such languages. These languages have two distinct modes of execution, one that constructs the dataflow model using a more expressive host language, and one that executes the dataflow model. An extremal example are spreadsheet programs in which the model-building mode is usually the manual manipulation of the spreadsheet itself in the application, and the model execution mode is the fully transparent propagation of changes whenever the value of a spreadsheet cell is changed. More recently, these dataflow oriented programming languages have become attractive because they facilitate an easy and efficient implementation of automatic differentiation (AD) [27] . Most conventional AD techniques apply to so-called “straight line code” which corresponds to ground-type recursion-free pure functional code. Be- n n cause models in general have type R R the restriction to straight-line code is not crippling. However, in practice constructing→ large models of a complex graph topology, for instance a neural network with tens of thousands of parameters, requires that the model is created using a more expressive programming language. Only the runtime version of the model is then straight-line code. There are some notable exceptions to

12:2 Steven W.T. Cheung, Dan R. Ghica, and Koko Muroya the rule, for example LSTM neural networks which have a stateful model [22], but this is a very popular programming paradigm. The straight-line-code model can be constructed in meta-programming style in platforms such as early TensorFlow, but this programming model is considered awkward, although very suitable for AD. Models specified seamlessly in an expressive programming languages are a more convenient way to program, but interaction with AD becomes much more difficult. Applying AD to higher order languages with or without effects remains an active area of research without definitive solutions [6].

1.2 Problem statement and contribution

Dataflow languages are extremely popular— the number of spreadsheet users alone greatly exceeds the number of programmers of any mainstream programming language — so studying them is arguably worthwhile. Semantically, so long as such languages are hosted inside safe languages, safety is not an issue. Safety is also not an issue in the case of ‘pure’ dataflow languages, in which the semantic model canbe expressed denotationally via systems of recursive and co-recursive equations, such as in the case of Lucid Synchrone [9]. In these cases the interesting issue is efficiency, particularly of memory utilisation. A semantically interesting question occurs in the case of languages which allow the explicit manipulation of the dataflow graph using imperative constructs. This is the case of Tensorflow [1] and of (imperative) self-adjusting computation (SAC) systems such as the Incremental library for OCaml [43]. The latter, although primarily intended for usage in high-performance computation [2], proved to be a convenient dataflow idiom for user interfaces and web programming. Constructing a dataflow graph imperatively can be convenient, but both Tensor- Flow and Incremental are unsafe, in the sense that ‘illegal’ dataflow graphs can be constructed during the execution, which leads to unsafe behaviour. In the case of TensorFlow it is possible for the dataflow evaluation to diverge because of cyclic dependencies, whereas in the case of Incremental illegal dataflow graphs with cycles cause crashes. These problems can be avoided by a judicious language design. In this paper we propose a programming language which is: imperative: the dataflow (computation) graph is explicitly manipulated using commands; functional: the language includes (call-by-value) PCF [48] as a subset; simply-typed: the type system is essentially that of PCF; modal: the execution of the dataflow (computation) graph is also controlled by explicit commands; parallel: the dataflow graph is executed in parallel. For such a programming language, establishing safety and memory efficiency are both challenging and non-trivial problems. Our theoretical contributions are: specification: we give a precise mathematical definition of the language using an abstract machine, harmonising the semantics of the PCF-like language with that of dataflow;

12:3 Transparent Synchronous Dataflow safety: we show that for any well-typed program the abstract machine executes without reaching illegal states; deterministic: we show that the parallel evaluation of the dataflow graph produces deterministic results; termination: moreover, we show that the execution of any recursion-free program with dataflow terminates by reaching the final state of the abstract machine; efficiency: we prove that no operation is ‘expensive’ in terms of time and memory utilisation.

Remark. These technical results add up to the most important contribution of the paper, which is one of programming language design. We demonstrated that functional and dataflow programming, resulting in the runtime creation of straight-line-code models, can be integrated seamlessly (syntactically and semantically), safely, and efficiently.

2 Synchronous Dataflow

Before technical details are provided let us try to understand the intended semantics of the language via some simple examples. This examples, although simple, should illustrate the versatility of the imperative style of constructing dataflow graphs. The starting language is call-by-value PCF, a typical language combining the simply-typed lambda calculus with arithmetic-logical operations and recursion. To it we add a new type of Cells along with facilities for manipulating them. The distinction between the type of cells and type of integers is more subtle than in languages with assignable state: the nodes in the dataflow graph have type Cell whereas their inputs and outputs are edges and have type Int. Note that in our graphs, the edges represent the dependency relations between nodes, therefore the input of a node would be represented by its outgoing edge (on top) while the output its incoming edge (at the bottom).

2.1 Dataflow graphs

The default mode of a program is to construct a dataflow graph, which we will describe now. The nodes of a dataflow graph are: Constants have a single output edge and produce the value stored in the node. Arithmetic-logic operators have two input edges and one output edge and compute the operation accordingly. Contraction nodes have multiple outputs and a single input, copying their input value to the outputs. They are labelled by a c. If-then-else have a control input and two input branches, but behave like selectors rather than control-flow operators. Cells have a single input, which can modify the stored value, which is the output. They are labelled with their current value in curly brackets.

12:4 Steven W.T. Cheung, Dan R. Ghica, and Koko Muroya

For example, the very simple dataflow graph (DFG) in 2 3 figure 1 computes the expression if y x then x else y, with {0} {1} variables (cells) initially x 0, y ≤1. The inputs of the = = c c cells are connected to the constants 2 and 3, respectively. On the first execution the DFG will produce 1 and update the <= cells. On any subsequent execution the DFG will produce 3.

Note that we are drawing the DFG rather unusually, with the if arrows indicating data dependencies rather than the dynamics of the data flow. Figure 1 If The only non-obvious behaviour here is that of the if statement. In a conventional language it is a control-flow operator, which will evaluate first the test then only one of the branches, depending onthe value of the test. In a dataflow setting both branches of the if statement compute, with the test selecting which value is propagated further down. Crucially,what we mean by “an execution” is a propagation of values in the DFG until they either reach the output or they 1 reach and subsequently updated every cell at most once. This - is the sense in which the DFG is “synchronous”, much like a {1} digital circuit. Along computation data travels independently and possibly asynchronously, but all memory cells serve as c synchronisation points. In figure 2 we can see a DFG which produces 1s and 0s, alternately, with each execution. On each Figure 2 Alternating execution the memory cell is updated x0 = 1 x. − Remark. The drawing of the DFG is unusual in that we point the arrows in the direction that indicates data dependencies rather than information flow. The reason is that the actual execution of the DFG, discussed in section 3, is demand-driven, which each DFG node first requesting data from their dependents, which request data from their dependents, and so on. This more elaborate execution mode requires some auxiliary nodes which we have omitted in this initial, informal, presentation.

2.2 Graph construction and manipulation

The host language is call-by-value PCF, extended with several key new operations used to create and manipulate DFGs: ref : Int Cell: create and return a new cell node in the dataflow graph initialised with→ an integer value; deref : Cell Int: take a cell node in the dataflow graph as argument and produce an incoming→ edge as result; root : Cell Int: take a cell node in the dataflow graph and return its outgoing edge; → link : Cell Int Unit: take a cell node and change its outgoing edge to the edge given as→ an argument.→ To construct programs it is convenient to also have more conventional assignment and dereferencing operations for instantly changing and reading the values of cells

12:5 Transparent Synchronous Dataflow

1 -

{1} x C 1 x f - + +

{i} {1} {0} {0}

C C C C

s s s s (a) (b) (c) (d)

Figure 3 Informal examples rather than just manipulating dependencies. In these operations the type Integer is interpreted in the conventional way, as a value. This dual treatment of the type of integers may seem ambiguous, but it is not, because each integer value can be also seen as an immutable node in the dataflow graph. Taking the value itself or the edge of the node means the same thing. assign : Cell Int Unit: change the constant of a cell instantly; → → peek : Int Int: extract the value of a cell instantly. Finally→ the command step : Int activates the computation in the dataflow graph by updating the contents of each cell in parallel, and at most once, if its dependencies have changed. This allows computing in dataflow graphs with cycles, provided that each cycle contains at least one cell. In effect, the model of propagation is synchronous, with the cells serving as synchronisation points. The command will return the number of updated cells in an update cycle. Knowing the number of updated cells is a useful convenience, as it will allow repeating the propagation step until the graph ‘stabilises’, i.e. no more updates happen. This is normally possible if and only if the dataflow graph lacks cycles. For the purpose of examples we consider a standard ‘let’ construct as syntactic sugar. Let us now consider a ‘hello world’ style example for dataflow computation: state machines. A generic state machine is created in our language by a function (sm) taking as arguments an initial value i, a transition function f , and a input x:

let sm = λi.λf .λx.let s = ref i in link s (f s x); deref s

Because of the way i is used as an argument to reference creation we can think of it as a plain integer value, whereas f and x should be thought of as edges in the dataflow graph. The resulting graph will have outgoing edges x, and incoming edge deref s. Besides the i-initialised cell-node it will also include a special ‘contraction’ node C so that the incoming edge can be used both as output and as cyclic dependency. The function f will be used, during execution, to create a desired dataflow graph. The resulting dataflow will have the general shape given in figure 3a.

12:6 Steven W.T. Cheung, Dan R. Ghica, and Koko Muroya

Let us call the function above sm and consider some simple instantiations, the examples are also available in the online visualiser1: oscillator is a state machine which alternates between 0 and 1, defined as let al t = sm 1 (λs.λi.1 deref s) 0. Note that the outgoing edge is not used, and 0 is a dummy value. The created− dataflow graph is represented informally in figure 3b, where the sub-graph produced when the particular transition function was supplied now has nodes for addition and the constant 1. The cell is initialised to 1. sum is a state machine which accumulates the value of its inputs into the state, defined as let sum = λx.sm 0 (λs.λi.i + deref s) x. The dataflow graph is sketched out in figure 3c. composite is a state machine which connects the incoming edge of the oscillator to the outgoing edge of the accumulator, defined as let a = sum(deref al t). It can be seen in figure 3d. The code above only constructs the dataflow graph. To execute it we need to execute the step command along with peek a to read the output. After one step, for example, the first cell will change its stored value from 1 to 0, and the second one from0to1. After another step the cells will further change to 1 and 1, respectively, and so on. Similar programs written in Lucid Synchrone and ReactiveML are shown in appendix A.

Remark. Although the language is modal, with distinct executions for the PCF-like fragment and the DFG fragment, the syntax of the language is uniform. So the language lacks the “metaprogramming” feel of TensorFlow and other embedded DSL-like solutions. Concretely, any operator is used in the same way whether as a part of the host language or the DFG. For example, when we write u + v the semantic interpretation is able to tease out whether this is PCF addition or DFG addition. This requires no static analysis or other syntactic solutions such as types, type classes, operator overloading and so on. This is akin to operator overloading, except that it is realised an a purely semantic way. Establishing a “semantic context”, defined by its history of execution, is as far as we know a novel approach which, as we shall see, will require a novel approach to semantics.

2.3 Formal syntax

The calculus is an extension of the simply-typed lambda calculus with base types integers, integer cells, and unit. Let γ ::= Int Cell Unit. These are the base types. | | The language has simple types as defined by the grammar τ ::= γ τ τ. Terms are defined by the grammar below with $ being arithmetic operations.| →

t ::= x λx.t t t n op if t then t else t rec x.t | | | | | | where op ranges over arithmetic operators +, , , : Int Int Int and the imperative operations on dataflow graphs mentioned− × earlier.÷ → The →typing rules of the calculus are the standard ones for the simply-typed call-by-value PCF (figure 4).

1 https://cwtsteven.github.io/TSD-visual?ex=alt/

12:7 Transparent Synchronous Dataflow

Γ t0 : τ τ0 Γ t : τ ` → ` Γ , x : τ x : τ Γ n : Int Γ op : τ Γ t0 t : τ0 ` ` ` ` , f : t : Γ , x : τ t : τ0 Γ t : Int Γ t1 : γ Γ t1 : γ Γ τ τ0 τ τ0 ` ` ` ` → ` → Γ λx.t : τ τ0 Γ if t then t1 else t2 : γ Γ rec f .t : τ τ0 ` → ` ` →

Figure 4 Typing rules

3 Abstract machine semantics

3.1 The Dynamic Geometry of Interaction

We will formulate the semantics of the language using a graph-rewriting abstract machine called the Dynamic Geometry of Interaction Machine (DGoIM). An abstract machine semantics has the desirable feature that it can allow reasoning about the cost of computation. In fact the DGoIM machine has been shown to be optimal, in a technical sense [4], for a variety of reduction strategies for the lambda calculus [46]. Abstract machines have been generally considered unsuitable for reasoning about programming languages. However, the DGoIM has been used to define and reason about the safety of ‘graph abstraction’, an exotic operation inspired by TensorFlow which converts local state variables into function parameters [44]. A generalisation of the DGoIM machine has also been used to reason about observational equivalence in languages with effects [24]. The origins of the DGoIM are in token abstract machines [17] giving semantics to linear logic proofs via the ‘Geometry of Interaction’ [25]. Using translations of lambda calculus into its linear version these abstract machines have been also used to model PCF and related languages [39]. These models proved to be interesting as they lead to space-efficient compilation schemes which have been used, among other things, to compile functional languages into circuits [23]. The motivation for a ‘dynamic’ version of the machine was that the original version only gives an efficient model for call-by-name. To represent call-by-value notonly soundly but also efficiently the ‘token’ that traverses the machine during execution also modifies it, thus preventing full re-evaluations of components which have been already evaluated. Although the graph-rewriting-based approach of the DGoIM is new, and hence it may appear unintuitive at a first sight, it is in fact closely related to rewrites onthe abstract syntax tree of the term, with a few tweaks: contraction: Unlike a standard AST in which variables sit in the ‘nodes’ of the tree, in the DGoIM representation variables with the same name and the same scope are ‘joined’ using ‘contraction’ nodes. Moreover, when the binder of a variable occurs the edges that correspond to the variable connect back to the binder. In figure 5 you can compare the conventional AST representation of λx.x x to its DGoIM representation. The graph contains some other GoI-inspired artefacts which we discuss below.

12:8 Steven W.T. Cheung, Dan R. Ghica, and Koko Muroya boxes: In the same figure we can see, that the lambda term is ‘boxed’. This canbe understood as the sub-graph corresponding to the lambda term is a single entity— for purposes of copying or deleting. This is part of the machinery that allows a precise cost of computation to be associated with graph rewrite. linear logic: Besides the contraction node (C) we can also see a !-labelled node (in grey) which is also inherited from linear logic. This node, along with ? nodes which will be seen later, serve as interface nodes to boxes, for arguments and non-local variables. Graph rewriting in general can be expensive, in particular the identification of redexes as sub-graphs. In DGoIM this is dealt with by making the rewriting ‘focussed’, i.e. C relative to a special node in the graph which we call ‘the x x token’. The token will traverse the graph and trigger re- x @ @ ductions as needed. In terms of conventional abstract ma- λ λ chines, the movement of the token along an edge, seeking ! a redex, is akin to the ‘narrowing’ of the context in a term abstract machine, whereas the movement against the edge, Figure 5 AST vs DGoIM after a reduction, corresponds to a ‘broadening’ of a term- reducing abstract machine. A visualiser is also available for demonstrating the step-by-step execution of the machine.2 The version of DGoIM machine presented here is essentially the original one, with the following extensions: Graph-construction: Semantics for imperative operations for constructing the dataflow graph. These do not represent significant changes to the machine but are rather straightforward extensions. Graph-execution: When the ‘step’ command is executed the program changes modes of operations, from the functional-imperative mode of execution of graph construction to the synchronous dataflow mode of execution defined by the graph. This requires a non-trivial enhancement of the DGoIM, primarily by enabling parallel execution.

3.2 Graph and translation

In this section we present the technical details of the DGOI machine.

A graph G is a set of nodes which are partitioned into proper nodes NodeG (or just ‘nodes’) and port nodes PortG (or just ‘ports’), and a set of directed edges connecting ports and nodes. Every node is associated and connected with several ports and each edge has at least one connecting port and there are no open edges. Every port is the source of at most one edge and the target of another. We also call the source and the target of a node the incoming port (or in-port) and the outgoing port (or out-port) respectively. For example the +-node is connected to two out-ports and one in-port. If a graph contains edges between two ports they are identified by an edge homeomorphism; our graphs are quotiented by the congruence induced by edge homeomorphisms in an appropriate category of graphs [32]. We often denote a graph

2 https://cwtsteven.github.io/TSD-visual/

12:9 Transparent Synchronous Dataflow

AAAB9HicbVDLSgMxFL1TX7W+qm4EN8EiuCozVdBloRuXFewD2qFk0kwbmmTGJFMoQ7/DjQtF3Pox7vwbM+0stPVA4HDOvdyTE8ScaeO6305hY3Nre6e4W9rbPzg8Kh+ftHWUKEJbJOKR6gZYU84kbRlmOO3GimIRcNoJJo3M70yp0iySj2YWU1/gkWQhI9hYye8LbMZKpA3K+XxQrrhVdwG0TrycVCBHc1D+6g8jkggqDeFY657nxsZPsTKMcDov9RNNY0wmeER7lkosqPbTReg5urTKEIWRsk8atFB/b6RYaD0TgZ3MQupVLxP/83qJCe/8lMk4MVSS5aEw4chEKGsADZmixPCZJZgoZrMiMsYKE2N7KtkSvNUvr5N2repdV2sPN5X6WV5HEc7hAq7Ag1uowz00oQUEnuAZXuHNmTovzrvzsRwtOPnOKfyB8/kDIXKSMw==

AAAB73icbVDLSgNBEOz1GeMr6tHLYBA8hd0o6DHgxWME84BkCb2TSTJkdnacmRXCkp/w4kERr/6ON//GSbIHTSxoKKq66e6KlODG+v63t7a+sbm1Xdgp7u7tHxyWjo6bJkk1ZQ2aiES3IzRMcMkallvB2kozjCPBWtH4dua3npg2PJEPdqJYGONQ8gGnaJ3U7o5RKewFvVLZr/hzkFUS5KQMOeq90le3n9A0ZtJSgcZ0Al/ZMENtORVsWuymhimkYxyyjqMSY2bCbH7vlJw7pU8GiXYlLZmrvycyjI2ZxJHrjNGOzLI3E//zOqkd3IQZlyq1TNLFokEqiE3I7HnS55pRKyaOINXc3UroCDVS6yIquhCC5ZdXSbNaCS4r1furco3kcRTgFM7gAgK4hhrcQR0aQEHAM7zCm/fovXjv3seidc3LZ07gD7zPH7aej6U= Cell AAAB73icbVDLSgNBEOz1GeMr6tHLYBA8hd0o6DHgxWME84BkCb2TSTJkdnacmRXCkp/w4kERr/6ON//GSbIHTSxoKKq66e6KlODG+v63t7a+sbm1Xdgp7u7tHxyWjo6bJkk1ZQ2aiES3IzRMcMkallvB2kozjCPBWtH4dua3npg2PJEPdqJYGONQ8gGnaJ3U7o5RKewFvVLZr/hzkFUS5KQMOeq90le3n9A0ZtJSgcZ0Al/ZMENtORVsWuymhimkYxyyjqMSY2bCbH7vlJw7pU8GiXYlLZmrvycyjI2ZxJHrjNGOzLI3E//zOqkd3IQZlyq1TNLFokEqiE3I7HnS55pRKyaOINXc3UroCDVS6yIquhCC5ZdXSbNaCS4r1furco3kcRTgFM7gAgK4hhrcQR0aQEHAM7zCm/fovXjv3seidc3LZ07gD7zPH7aej6U=  AAAB73icbVDLSgNBEOz1GeMr6tHLYBA8hd0o6DHgxWME84BkCb2TSTJkdnacmRXCkp/w4kERr/6ON//GSbIHTSxoKKq66e6KlODG+v63t7a+sbm1Xdgp7u7tHxyWjo6bJkk1ZQ2aiES3IzRMcMkallvB2kozjCPBWtH4dua3npg2PJEPdqJYGONQ8gGnaJ3U7o5RKexVe6WyX/HnIKskyEkZctR7pa9uP6FpzKSlAo3pBL6yYYbacirYtNhNDVNIxzhkHUclxsyE2fzeKTl3Sp8MEu1KWjJXf09kGBsziSPXGaMdmWVvJv7ndVI7uAkzLlVqmaSLRYNUEJuQ2fOkzzWjVkwcQaq5u5XQEWqk1kVUdCEEyy+vkma1ElxWqvdX5RrJ4yjAKZzBBQRwDTW4gzo0gIKAZ3iFN+/Re/HevY9F65qXz5zAH3ifP7gij6Y=   1 2 !(1 2) 1 ⌘AAAB63icbVBNS8NAEN3Ur1q/qh69LBbBU0mqoMeCF48V7Ae0oWy2k3bp7ibsToQS+he8eFDEq3/Im//GpM1BWx8MPN6bYWZeEEth0XW/ndLG5tb2Tnm3srd/cHhUPT7p2CgxHNo8kpHpBcyCFBraKFBCLzbAVCChG0zvcr/7BMaKSD/iLAZfsbEWoeAMc2kAyIbVmlt3F6DrxCtIjRRoDatfg1HEEwUauWTW9j03Rj9lBgWXMK8MEgsx41M2hn5GNVNg/XRx65xeZMqIhpHJSiNdqL8nUqasnakg61QMJ3bVy8X/vH6C4a2fCh0nCJovF4WJpBjR/HE6EgY4yllGGDciu5XyCTOMYxZPJQvBW315nXQade+q3ni4rjVpEUeZnJFzckk8ckOa5J60SJtwMiHP5JW8Ocp5cd6dj2VrySlmTskfOJ8//+eOGg== Cell !Int !Int !Int AAACD3icbVDLTgIxFO34RHyNunRTJBrckBk00SWJG5eYyCMBQu6UAg3tTNN2TMiEP3Djr7hxoTFu3brzbyzDLBQ8TZPTc+7N7T2B5Ewbz/t2VlbX1jc2c1v57Z3dvX334LCho1gRWicRj1QrAE05C2ndMMNpSyoKIuC0GYxvZn7zgSrNovDeTCTtChiGbMAIGCv13LOkMC11xiAl9PxOwR4Rc8MEyPQxNyrnPbfolb0UeJn4GSmiDLWe+9XpRyQWNDSEg9Zt35Omm4AyjHA6zXdiTSWQMQxp29IQBNXdJN1nik+t0seDSNkbGpyqvzsSEFpPRGArBZiRXvRm4n9eOzaD627CQhkbGpL5oEHMsYnwLBzcZ4oSwyeWAFHM/hWTESggxkaYtyH4iysvk0al7F+UK3eXxSrO4sihY3SCSshHV6iKblEN1RFBj+gZvaI358l5cd6dj3npipP1HKE/cD5/AMflmx8= (

AAAB6HicbVBNS8NAEJ3Ur1q/qh69LBbBU0mqoMeCF48t2A9oQ9lsJ+3a3STsboQS+gu8eFDEqz/Jm//GbZuDtj4YeLw3w8y8IBFcG9f9dgobm1vbO8Xd0t7+weFR+fikreNUMWyxWMSqG1CNgkfYMtwI7CYKqQwEdoLJ3dzvPKHSPI4ezDRBX9JRxEPOqLFSUw7KFbfqLkDWiZeTCuRoDMpf/WHMUomRYYJq3fPcxPgZVYYzgbNSP9WYUDahI+xZGlGJ2s8Wh87IhVWGJIyVrciQhfp7IqNS66kMbKekZqxXvbn4n9dLTXjrZzxKUoMRWy4KU0FMTOZfkyFXyIyYWkKZ4vZWwsZUUWZsNiUbgrf68jpp16reVbXWvK7USR5HEc7gHC7Bgxuowz00oAUMEJ7hFd6cR+fFeXc+lq0FJ585hT9wPn8AzKGM0w==

AAAB6HicbVBNS8NAEJ3Ur1q/qh69LBbBU0mqoMeCF48t2A9oQ9lsJ+3azSbsboQS+gu8eFDEqz/Jm//GbZuDtj4YeLw3w8y8IBFcG9f9dgobm1vbO8Xd0t7+weFR+fikreNUMWyxWMSqG1CNgktsGW4EdhOFNAoEdoLJ3dzvPKHSPJYPZpqgH9GR5CFn1FipqQblilt1FyDrxMtJBXI0BuWv/jBmaYTSMEG17nluYvyMKsOZwFmpn2pMKJvQEfYslTRC7WeLQ2fkwipDEsbKljRkof6eyGik9TQKbGdEzVivenPxP6+XmvDWz7hMUoOSLReFqSAmJvOvyZArZEZMLaFMcXsrYWOqKDM2m5INwVt9eZ20a1XvqlprXlfqJI+jCGdwDpfgwQ3U4R4a0AIGCM/wCm/Oo/PivDsfy9aCk8+cwh84nz/UNYzY

AAAB6HicbVBNS8NAEJ3Ur1q/qh69LBbBU0mqoMeCF48t2A9oQ9lsJ+3azSbsboQS+gu8eFDEqz/Jm//GbZuDtj4YeLw3w8y8IBFcG9f9dgobm1vbO8Xd0t7+weFR+fikreNUMWyxWMSqG1CNgktsGW4EdhOFNAoEdoLJ3dzvPKHSPJYPZpqgH9GR5CFn1FipqQflilt1FyDrxMtJBXI0BuWv/jBmaYTSMEG17nluYvyMKsOZwFmpn2pMKJvQEfYslTRC7WeLQ2fkwipDEsbKljRkof6eyGik9TQKbGdEzVivenPxP6+XmvDWz7hMUoOSLReFqSAmJvOvyZArZEZMLaFMcXsrYWOqKDM2m5INwVt9eZ20a1XvqlprXlfqJI+jCGdwDpfgwQ3U4R4a0AIGCM/wCm/Oo/PivDsfy9aCk8+cwh84nz/VuYzZ

() AAAB6HicbVBNS8NAEJ3Ur1q/qh69LBbBU0mqoMeCF48t2A9oQ9lsJu3azSbsboRS+gu8eFDEqz/Jm//GbZuDtj4YeLw3w8y8IBVcG9f9dgobm1vbO8Xd0t7+weFR+fikrZNMMWyxRCSqG1CNgktsGW4EdlOFNA4EdoLx3dzvPKHSPJEPZpKiH9Oh5BFn1FipGQ7KFbfqLkDWiZeTCuRoDMpf/TBhWYzSMEG17nluavwpVYYzgbNSP9OYUjamQ+xZKmmM2p8uDp2RC6uEJEqULWnIQv09MaWx1pM4sJ0xNSO96s3F/7xeZqJbf8plmhmUbLkoygQxCZl/TUKukBkxsYQyxe2thI2ooszYbEo2BG/15XXSrlW9q2qteV2pkzyOIpzBOVyCBzdQh3toQAsYIDzDK7w5j86L8+58LFsLTj5zCn/gfP4Avv2Myg==

AAAB6HicbVBNS8NAEJ3Ur1q/qh69LBbBU0mqoMeCF48t2A9oQ9lsJ+3azSbsboQS+gu8eFDEqz/Jm//GbZuDtj4YeLw3w8y8IBFcG9f9dgobm1vbO8Xd0t7+weFR+fikreNUMWyxWMSqG1CNgktsGW4EdhOFNAoEdoLJ3dzvPKHSPJYPZpqgH9GR5CFn1FipmQzKFbfqLkDWiZeTCuRoDMpf/WHM0gilYYJq3fPcxPgZVYYzgbNSP9WYUDahI+xZKmmE2s8Wh87IhVWGJIyVLWnIQv09kdFI62kU2M6ImrFe9ebif14vNeGtn3GZpAYlWy4KU0FMTOZfkyFXyIyYWkKZ4vZWwsZUUWZsNiUbgrf68jpp16reVbXWvK7USR5HEc7gHC7Bgxuowz00oAUMEJ7hFd6cR+fFeXc+lq0FJ585hT9wPn8A0S2M1g== p

AAAB6HicbVBNS8NAEJ3Ur1q/qh69LBbBU0mqoMeCF48t2A9oQ9lsJ+3azSbsboQS+gu8eFDEqz/Jm//GbZuDtj4YeLw3w8y8IBFcG9f9dgobm1vbO8Xd0t7+weFR+fikreNUMWyxWMSqG1CNgktsGW4EdhOFNAoEdoLJ3dzvPKHSPJYPZpqgH9GR5CFn1FipWR+UK27VXYCsEy8nFcjRGJS/+sOYpRFKwwTVuue5ifEzqgxnAmelfqoxoWxCR9izVNIItZ8tDp2RC6sMSRgrW9KQhfp7IqOR1tMosJ0RNWO96s3F/7xeasJbP+MySQ1KtlwUpoKYmMy/JkOukBkxtYQyxe2thI2poszYbEo2BG/15XXSrlW9q2qteV2pkzyOIpzBOVyCBzdQh3toQAsYIDzDK7w5j86L8+58LFsLTj5zCn/gfP4AiG2Mpg==

AAAB6XicbVBNS8NAEJ3Ur1q/qh69LFbBU0mqoMeCF49V7Ae0oWy2k3bpZhN2N0IJ/QdePCji1X/kzX/jts1BWx8MPN6bYWZekAiujet+O4W19Y3NreJ2aWd3b/+gfHjU0nGqGDZZLGLVCahGwSU2DTcCO4lCGgUC28H4dua3n1BpHstHM0nQj+hQ8pAzaqz00Dvrlytu1Z2DrBIvJxXI0eiXv3qDmKURSsME1brruYnxM6oMZwKnpV6qMaFsTIfYtVTSCLWfzS+dknOrDEgYK1vSkLn6eyKjkdaTKLCdETUjvezNxP+8bmrCGz/jMkkNSrZYFKaCmJjM3iYDrpAZMbGEMsXtrYSNqKLM2HBKNgRv+eVV0qpVvctq7f6qUid5HEU4gVO4AA+uoQ530IAmMAjhGV7hzRk7L86787FoLTj5zDH8gfP5Aw68jPA= AAAB83icbVDLSsNAFJ3UV62vqks3g0VwVZIq6LLgxmUF+4AmlMnkph06mYR5CCX0N9y4UMStP+POv3HSZqGtBwYO59zDvXPCjDOlXffbqWxsbm3vVHdre/sHh0f145OeSo2k0KUpT+UgJAo4E9DVTHMYZBJIEnLoh9O7wu8/gVQsFY96lkGQkLFgMaNEW8n3jYhAFmEsRvWG23QXwOvEK0kDleiM6l9+lFKTgNCUE6WGnpvpICdSM8phXvONgozQKRnD0FJBElBBvrh5ji+sEuE4lfYJjRfq70ROEqVmSWgnE6InatUrxP+8odHxbZAzkRkNgi4XxYZjneKiABwxCVTzmSWESmZvxXRCJKHa1lSzJXirX14nvVbTu2q2Hq4bbVzWUUVn6BxdIg/doDa6Rx3URRRl6Bm9ojfHOC/Ou/OxHK04ZeYU/YHz+QPzxpGE n s r m @ AAAB9XicbVDLSgMxFL1TX7W+qi7dBItQN2WmCrosuHFZwT6gHUsmvW1DM5khyShl6H+4caGIW//FnX9j2s5CWw8EDufcw705QSy4Nq777eTW1jc2t/LbhZ3dvf2D4uFRU0eJYthgkYhUO6AaBZfYMNwIbMcKaRgIbAXjm5nfekSleSTvzSRGP6RDyQecUWOlh24i+6hm4bR8Pu0VS27FnYOsEi8jJchQ7xW/uv2IJSFKwwTVuuO5sfFTqgxnAqeFbqIxpmxMh9ixVNIQtZ/Or56SM6v0ySBS9klD5urvREpDrSdhYCdDakZ62ZuJ/3mdxAyu/ZTLODEo2WLRIBHERGRWAelzhcyIiSWUKW5vJWxEFWXGFlWwJXjLX14lzWrFu6hU7y5LNZLVkYcTOIUyeHAFNbiFOjSAgYJneIU358l5cd6dj8Vozskyx/AHzucPY1SSUw== d $

AAAB9HicbVBNSwMxFHzrZ61fVS+Cl2ARPJXdKuix4MVjBbcttEvJptk2NMmuSbZQlv4OLx4U8eqP8ea/MdvuQVsHAsPMe7zJhAln2rjut7O2vrG5tV3aKe/u7R8cVo6OWzpOFaE+iXmsOiHWlDNJfcMMp51EUSxCTtvh+C732xOqNIvlo5kmNBB4KFnECDZWCnoCm5ESmS+ZmfUrVbfmzoFWiVeQKhRo9itfvUFMUkGlIRxr3fXcxAQZVoYRTmflXqppgskYD2nXUokF1UE2Dz1DF1YZoChW9kmD5urvjQwLracitJN5SL3s5eJ/Xjc10W2QMZmkhkqyOBSlHJkY5Q2gAVOUGD61BBPFbFZERlhhYmxPZVuCt/zlVdKq17yrWv3huto4LeoowRmcwyV4cAMNuIcm+EDgCZ7hFd6cifPivDsfi9E1p9g5gT9wPn8AUleSUw==

AAAB+HicbVBNS8NAFHypX7V+NOpF8LJaBE8lqYIeC170VsHaQhvKZrtpl242YXcj1JBf4sWDIl79Kd78N27aHLR1YGGYeY83O37MmdKO822VVlbX1jfKm5Wt7Z3dqr23/6CiRBLaJhGPZNfHinImaFszzWk3lhSHPqcdf3Kd+51HKhWLxL2extQL8UiwgBGsjTSwq/0Q67EM0/Q4uxU6G9g1p+7MgJaJW5AaFGgN7K/+MCJJSIUmHCvVc51YeymWmhFOs0o/UTTGZIJHtGeowCFVXjoLnqFTowxREEnzhEYz9fdGikOlpqFvJvOYatHLxf+8XqKDKy9lIk40FWR+KEg40hHKW0BDJinRfGoIJpKZrIiMscREm64qpgR38cvL5KFRd8/rjbuLWvOwqKMMR3ACZ+DCJTThBlrQBgIJPMMrvFlP1ov1bn3MR0tWsXMAf2B9/gAXNpM8 AAAB83icbVDLSgMxFL1TX7W+qm4EN8EiuCozVdBlwY3uKtgHdIaSSTNtaJIZkoxQhv6GGxeKuPVn3Pk3ZtpZaOuBwOGce7knJ0w408Z1v53S2vrG5lZ5u7Kzu7d/UD086ug4VYS2Scxj1QuxppxJ2jbMcNpLFMUi5LQbTm5zv/tElWaxfDTThAYCjySLGMHGSr4vsBkrkd1LMxtUa27dnQOtEq8gNSjQGlS//GFMUkGlIRxr3ffcxAQZVoYRTmcVP9U0wWSCR7RvqcSC6iCbZ56hc6sMURQr+6RBc/X3RoaF1lMR2sk8o172cvE/r5+a6CbImExSQyVZHIpSjkyM8gLQkClKDJ9agoliNisiY6wwMbamii3BW/7yKuk06t5lvfFwVWueFHWU4RTO4AI8uIYm3EEL2kAggWd4hTcndV6cd+djMVpyip1j+APn8wd24ZHU Cell

AAAB73icbVDLSgNBEOz1GeMr6tHLYBA8hd0o6DHgxWME84BkCb2TSTJkdnacmRXCkp/w4kERr/6ON//GSbIHTSxoKKq66e6KlODG+v63t7a+sbm1Xdgp7u7tHxyWjo6bJkk1ZQ2aiES3IzRMcMkallvB2kozjCPBWtH4dua3npg2PJEPdqJYGONQ8gGnaJ3U7o5RKexVe6WyX/HnIKskyEkZctR7pa9uP6FpzKSlAo3pBL6yYYbacirYtNhNDVNIxzhkHUclxsyE2fzeKTl3Sp8MEu1KWjJXf09kGBsziSPXGaMdmWVvJv7ndVI7uAkzLlVqmaSLRYNUEJuQ2fOkzzWjVkwcQaq5u5XQEWqk1kVUdCEEyy+vkma1ElxWqvdX5RrJ4yjAKZzBBQRwDTW4gzo0gIKAZ3iFN+/Re/HevY9F65qXz5zAH3ifP7gij6Y= AAAB63icbVBNS8NAEN3Ur1q/qh69LBbBU0mqoMeCF48V7Ae0oWy2k3bp7ibsToQS+he8eFDEq3/Im//GpM1BWx8MPN6bYWZeEEth0XW/ndLG5tb2Tnm3srd/cHhUPT7p2CgxHNo8kpHpBcyCFBraKFBCLzbAVCChG0zvcr/7BMaKSD/iLAZfsbEWoeAMc2kAyIbVmlt3F6DrxCtIjRRoDatfg1HEEwUauWTW9j03Rj9lBgWXMK8MEgsx41M2hn5GNVNg/XRx65xeZMqIhpHJSiNdqL8nUqasnakg61QMJ3bVy8X/vH6C4a2fCh0nCJovF4WJpBjR/HE6EgY4yllGGDciu5XyCTOMYxZPJQvBW315nXQade+q3ni4rjVpEUeZnJFzckk8ckOa5J60SJtwMiHP5JW8Ocp5cd6dj2VrySlmTskfOJ8//+eOGg== AAACDHicbVC7TgMxEPSFVwivACWNIUGiiu6OAspINJRBIg8pF0V7ji+xYvss24cURfkAGn6FhgKEaPkAOv4G51FAwlqWxjOzWu/EijNjff/by62tb2xu5bcLO7t7+wfFw6OGSTNNaJ2kPNWtGAzlTNK6ZZbTltIURMxpMx7eTPXmA9WGpfLejhTtCOhLljAC1lHdYqkcDUEp6AbRqTsi45YJULPHXAjLzuVX/FnhVRAsQAktqtYtfkW9lGSCSks4GNMOfGU7Y9CWEU4nhSgzVAEZQp+2HZQgqOmMZ8tM8LljejhJtbvS4hn7u2MMwpiRiJ1TgB2YZW1K/qe1M5tcd8ZMqsxSSeaDkoxjm+JpMrjHNCWWjxwAopn7KyYD0ECsy6/gQgiWV14FjbASXFbCu7BUxYs48ugEnaELFKArVEW3qIbqiKBH9Ixe0Zv35L14797H3JrzFj3H6E95nz93upnd 1(2 2 Int Unit !Int ⌘ !Int !Int !Int

AAAB7XicbVDLSgNBEOz1GeMr6tHLYBA8hd0o6DHgxWME84BkCb2TSTJmdnaYmRXCkn/w4kERr/6PN//GSbIHTSxoKKq66e6KlODG+v63t7a+sbm1Xdgp7u7tHxyWjo6bJkk1ZQ2aiES3IzRMcMkallvB2kozjCPBWtH4dua3npg2PJEPdqJYGONQ8gGnaJ3U7I5RKeyVyn7Fn4OskiAnZchR75W+uv2EpjGTlgo0phP4yoYZasupYNNiNzVMIR3jkHUclRgzE2bza6fk3Cl9Mki0K2nJXP09kWFszCSOXGeMdmSWvZn4n9dJ7eAmzLhUqWWSLhYNUkFsQmavkz7XjFoxcQSp5u5WQkeokVoXUNGFECy/vEqa1UpwWaneX5VrJI+jAKdwBhcQwDXU4A7q0AAKj/AMr/DmJd6L9+59LFrXvHzmBP7A+/wBjUCPAQ==

AAAB/3icbVDNS8MwHE3n15xfVUEEL9EheBrtFPQ4EMTjBPcBWxlplm5hSVqSVBi1B/8VLx4U8eq/4c3/xrTrQTcfhDze+/3Iy/MjRpV2nG+rtLS8srpWXq9sbG5t79i7e20VxhKTFg5ZKLs+UoRRQVqaaka6kSSI+4x0/Ml15nceiFQ0FPd6GhGPo5GgAcVIG2lgHyTHaZ8jPZY8yW/fT27SdGBXnZqTAy4StyBVUKA5sL/6wxDHnAiNGVKq5zqR9hIkNcWMpJV+rEiE8ASNSM9QgThRXpLnT+GpUYYwCKU5QsNc/b2RIK7UlPtmMouo5r1M/M/rxTq48hIqolgTgWcPBTGDOoRZGXBIJcGaTQ1BWFKTFeIxkghrU1nFlODOf3mRtOs197xWv7uoNg6LOsrgCJyAM+CCS9AAt6AJWgCDR/AMXsGb9WS9WO/Wx2y0ZBU7++APrM8fpEGWXw==

AAAB6nicbVBNS8NAEJ3Ur1q/qh69LBbBU0lqQY8FLx4r2g9oQ9lsN+3SzSbsToQS+hO8eFDEq7/Im//GbZuDtj4YeLw3w8y8IJHCoOt+O4WNza3tneJuaW//4PCofHzSNnGqGW+xWMa6G1DDpVC8hQIl7yaa0yiQvBNMbud+54lrI2L1iNOE+xEdKREKRtFKD32VDsoVt+ouQNaJl5MK5GgOyl/9YczSiCtkkhrT89wE/YxqFEzyWamfGp5QNqEj3rNU0YgbP1ucOiMXVhmSMNa2FJKF+nsio5Ex0yiwnRHFsVn15uJ/Xi/F8MbPhEpS5IotF4WpJBiT+d9kKDRnKKeWUKaFvZWwMdWUoU2nZEPwVl9eJ+1a1buq1u7rlQbJ4yjCGZzDJXhwDQ24gya0gMEInuEV3hzpvDjvzseyteDkM6fwB87nD1X3jbk= Cell !Int Cell !Int AAAB/3icbVDNS8MwHE3n15xfVUEEL9EheBrtFPQ4EMTjBPcBWxlplm5hSVqSVBi1B/8VLx4U8eq/4c3/xrTrQTcfhDze+/3Iy/MjRpV2nG+rtLS8srpWXq9sbG5t79i7e20VxhKTFg5ZKLs+UoRRQVqaaka6kSSI+4x0/Ml15nceiFQ0FPd6GhGPo5GgAcVIG2lgHyTHaZ8jPZY8yW/fT27SdGBXnZqTAy4StyBVUKA5sL/6wxDHnAiNGVKq5zqR9hIkNcWMpJV+rEiE8ASNSM9QgThRXpLnT+GpUYYwCKU5QsNc/b2RIK7UlPtmMouo5r1M/M/rxTq48hIqolgTgWcPBTGDOoRZGXBIJcGaTQ1BWFKTFeIxkghrU1nFlODOf3mRtOs197xWv7uoNg6LOsrgCJyAM+CCS9AAt6AJWgCDR/AMXsGb9WS9WO/Wx2y0ZBU7++APrM8fpEGWXw== ! ! ⌘AAAB63icbVBNS8NAEN3Ur1q/qh69LBbBU0mqoMeCF48V7Ae0oWy2k3bp7ibsToQS+he8eFDEq3/Im//GpM1BWx8MPN6bYWZeEEth0XW/ndLG5tb2Tnm3srd/cHhUPT7p2CgxHNo8kpHpBcyCFBraKFBCLzbAVCChG0zvcr/7BMaKSD/iLAZfsbEWoeAMc2kAyIbVmlt3F6DrxCtIjRRoDatfg1HEEwUauWTW9j03Rj9lBgWXMK8MEgsx41M2hn5GNVNg/XRx65xeZMqIhpHJSiNdqL8nUqasnakg61QMJ3bVy8X/vH6C4a2fCh0nCJovF4WJpBjR/HE6EgY4yllGGDciu5XyCTOMYxZPJQvBW315nXQade+q3ni4rjVpEUeZnJFzckk8ckOa5J60SJtwMiHP5JW8Ocp5cd6dj2VrySlmTskfOJ8//+eOGg== ⌘AAAB63icbVBNS8NAEN3Ur1q/qh69LBbBU0mqoMeCF48V7Ae0oWy2k3bp7ibsToQS+he8eFDEq3/Im//GpM1BWx8MPN6bYWZeEEth0XW/ndLG5tb2Tnm3srd/cHhUPT7p2CgxHNo8kpHpBcyCFBraKFBCLzbAVCChG0zvcr/7BMaKSD/iLAZfsbEWoeAMc2kAyIbVmlt3F6DrxCtIjRRoDatfg1HEEwUauWTW9j03Rj9lBgWXMK8MEgsx41M2hn5GNVNg/XRx65xeZMqIhpHJSiNdqL8nUqasnakg61QMJ3bVy8X/vH6C4a2fCh0nCJovF4WJpBjR/HE6EgY4yllGGDciu5XyCTOMYxZPJQvBW315nXQade+q3ni4rjVpEUeZnJFzckk8ckOa5J60SJtwMiHP5JW8Ocp5cd6dj2VrySlmTskfOJ8//+eOGg== !(1 2) !(  ) ⌫   F F AAACD3icbVDLTgIxFO34RHyNunRTJBrckBk00SWJG5eYyCMBQu6UAg3tTNN2TMiEP3Djr7hxoTFu3brzbyzDLBQ8TZPTc+7N7T2B5Ewbz/t2VlbX1jc2c1v57Z3dvX334LCho1gRWicRj1QrAE05C2ndMMNpSyoKIuC0GYxvZn7zgSrNovDeTCTtChiGbMAIGCv13LOkMC11xiAl9PxOwR4Rc8MEyPQxNyrnPbfolb0UeJn4GSmiDLWe+9XpRyQWNDSEg9Zt35Omm4AyjHA6zXdiTSWQMQxp29IQBNXdJN1nik+t0seDSNkbGpyqvzsSEFpPRGArBZiRXvRm4n9eOzaD627CQhkbGpL5oEHMsYnwLBzcZ4oSwyeWAFHM/hWTESggxkaYtyH4iysvk0al7F+UK3eXxSrO4sihY3SCSshHV6iKblEN1RFBj+gZvaI358l5cd6dj3npipP1HKE/cD5/AMflmx8= 1 2 ( AAACD3icbVDLTgIxFO34RHyNunRTJBrckBk00SWJG5eYyCMBQu6UAg3tTNN2TMiEP3Djr7hxoTFu3brzbyzDLBQ8TZPTc+7N7T2B5Ewbz/t2VlbX1jc2c1v57Z3dvX334LCho1gRWicRj1QrAE05C2ndMMNpSyoKIuC0GYxvZn7zgSrNovDeTCTtChiGbMAIGCv13LOkMC11xiAl9PxOwR4Rc8MEyPQxNyrnPbfolb0UeJn4GSmiDLWe+9XpRyQWNDSEg9Zt35Omm4AyjHA6zXdiTSWQMQxp29IQBNXdJN1nik+t0seDSNkbGpyqvzsSEFpPRGArBZiRXvRm4n9eOzaD627CQhkbGpL5oEHMsYnwLBzcZ4oSwyeWAFHM/hWTESggxkaYtyH4iysvk0al7F+UK3eXxSrO4sihY3SCSshHV6iKblEN1RFBj+gZvaI358l5cd6dj3npipP1HKE/cD5/AMflmx8= (

AAAB6HicbVBNS8NAEJ3Ur1q/qh69LBbBU0mqoMeCF48t2A9oQ9lsJ+3azSbsboQS+gu8eFDEqz/Jm//GbZuDtj4YeLw3w8y8IBFcG9f9dgobm1vbO8Xd0t7+weFR+fikreNUMWyxWMSqG1CNgktsGW4EdhOFNAoEdoLJ3dzvPKHSPJYPZpqgH9GR5CFn1FipSQflilt1FyDrxMtJBXI0BuWv/jBmaYTSMEG17nluYvyMKsOZwFmpn2pMKJvQEfYslTRC7WeLQ2fkwipDEsbKljRkof6eyGik9TQKbGdEzVivenPxP6+XmvDWz7hMUoOSLReFqSAmJvOvyZArZEZMLaFMcXsrYWOqKDM2m5INwVt9eZ20a1XvqlprXlfqJI+jCGdwDpfgwQ3U4R4a0AIGCM/wCm/Oo/PivDsfy9aCk8+cwh84nz+6cYzH

AAAB6nicbVDLSgNBEOz1GeMr6tHLYBA8hd0o6DHgxWNE84BkCbOT2WTIzOwy0yuEkE/w4kERr36RN//GSbIHTSxoKKq66e6KUiks+v63t7a+sbm1Xdgp7u7tHxyWjo6bNskM4w2WyMS0I2q5FJo3UKDk7dRwqiLJW9Hodua3nrixItGPOE55qOhAi1gwik566KqsVyr7FX8OskqCnJQhR71X+ur2E5YprpFJam0n8FMMJ9SgYJJPi93M8pSyER3wjqOaKm7DyfzUKTl3Sp/EiXGlkczV3xMTqqwdq8h1KopDu+zNxP+8TobxTTgROs2Qa7ZYFGeSYEJmf5O+MJyhHDtCmRHuVsKG1FCGLp2iCyFYfnmVNKuV4LJSvb8q10geRwFO4QwuIIBrqMEd1KEBDAbwDK/w5knvxXv3Phata14+cwJ/4H3+AFRyjbg= µ

AAAB6HicbVBNS8NAEJ3Ur1q/qh69LBbBU0mqoMeCF48t2A9oQ9lsJ+3azSbsboQS+gu8eFDEqz/Jm//GbZuDtj4YeLw3w8y8IBFcG9f9dgobm1vbO8Xd0t7+weFR+fikreNUMWyxWMSqG1CNgktsGW4EdhOFNAoEdoLJ3dzvPKHSPJYPZpqgH9GR5CFn1FipKQblilt1FyDrxMtJBXI0BuWv/jBmaYTSMEG17nluYvyMKsOZwFmpn2pMKJvQEfYslTRC7WeLQ2fkwipDEsbKljRkof6eyGik9TQKbGdEzVivenPxP6+XmvDWz7hMUoOSLReFqSAmJvOvyZArZEZMLaFMcXsrYWOqKDM2m5INwVt9eZ20a1XvqlprXlfqJI+jCGdwDpfgwQ3U4R4a0AIGCM/wCm/Oo/PivDsfy9aCk8+cwh84nz/LHYzS

a AAAB6HicbVBNS8NAEJ3Ur1q/qh69rBbBU0mqoMeCF48t2FpoQ9lsJ+3azSbsboQS+gu8eFDEqz/Jm//GbZuDtj4YeLw3w8y8IBFcG9f9dgpr6xubW8Xt0s7u3v5B+fCoreNUMWyxWMSqE1CNgktsGW4EdhKFNAoEPgTj25n/8IRK81jem0mCfkSHkoecUWOl5mm/XHGr7hxklXg5qUCORr/81RvELI1QGiao1l3PTYyfUWU4Ezgt9VKNCWVjOsSupZJGqP1sfuiUnFtlQMJY2ZKGzNXfExmNtJ5Ege2MqBnpZW8m/ud1UxPe+BmXSWpQssWiMBXExGT2NRlwhcyIiSWUKW5vJWxEFWXGZlOyIXjLL6+Sdq3qXVZrzatKneRxFOEEzuACPLiGOtxBA1rAAOEZXuHNeXRenHfnY9FacPKZY/gD5/MHWXGMhw==

AAAB+XicbVDLSsNAFL2pr1pfUTeCm8EiuCpJFXRZcOOygn1AE8pkMmmHTiZhZlIooX/ixoUibv0Td/6NkzYLbT1w4XDOvTP3niDlTGnH+bYqG5tb2zvV3dre/sHhkX180lVJJgntkIQnsh9gRTkTtKOZ5rSfSorjgNNeMLkv/N6USsUS8aRnKfVjPBIsYgRrIw1t28u9TIRUFg8g4c2Hdt1pOAugdeKWpA4l2kP7ywsTksVUaMKxUgPXSbWfY6kZ4XRe8zJFU0wmeEQHhgocU+Xni83n6NIoIYoSaUpotFB/T+Q4VmoWB6YzxnqsVr1C/M8bZDq683Mm0kxTQZYfRRlHOkFFDChkkhLNZ4ZgIpnZFZExlphoE1bNhOCunrxOus2Ge91oPt7UW2dlHFU4hwu4AhduoQUP0IYOEJjCM7zCm5VbL9a79bFsrVjlzCn8gfX5A6H8k4U= l ifAAAB8nicbVDLSsNAFL2pr1pfVZduBovgqiRV0GXBjcsK9gFtKJPppB06mYSZG6GEfoYbF4q49Wvc+TdO2iy09cDA4Zx7mXNPkEhh0HW/ndLG5tb2Tnm3srd/cHhUPT7pmDjVjLdZLGPdC6jhUijeRoGS9xLNaRRI3g2md7nffeLaiFg94izhfkTHSoSCUbRSfxBRnAjMRDgfVmtu3V2ArBOvIDUo0BpWvwajmKURV8gkNabvuQn6GdUomOTzyiA1PKFsSse8b6miETd+tog8JxdWGZEw1vYpJAv190ZGI2NmUWAn84hm1cvF/7x+iuGtnwmVpMgVW34UppJgTPL7yUhozlDOLKFMC5uVsAnVlKFtqWJL8FZPXiedRt27qjcermtNUtRRhjM4h0vw4AaacA8taAODGJ7hFd4cdF6cd+djOVpyip1T+APn8wfBZpF0 ! ? C { } -

AAAB+XicbVBNS8NAFHypX7V+Rb0IXlaL4KkkVdBjwYvHCsYW2lA22027dLMJu5tCCfknXjwo4tV/4s1/46bNQVsHFoaZ93izEyScKe0431ZlbX1jc6u6XdvZ3ds/sA+PnlScSkI9EvNYdgOsKGeCepppTruJpDgKOO0Ek7vC70ypVCwWj3qWUD/CI8FCRrA20sC2s7O8H2E9llHmCabzgV13Gs4caJW4JalDifbA/uoPY5JGVGjCsVI910m0n2GpGeE0r/VTRRNMJnhEe4YKHFHlZ/PkObowyhCFsTRPaDRXf29kOFJqFgVmsgiplr1C/M/rpTq89TMmklRTQRaHwpQjHaOiBjRkkhLNZ4ZgIpnJisgYS0y0KatmSnCXv7xKnpoN96rRfLiut07KOqpwCudwCS7cQAvuoQ0eEJjCM7zCm5VZL9a79bEYrVjlzjH8gfX5A/KDk7s=

AAAB7XicbVDLSgNBEOz1GeMr6kXwMhoET2E3CnoMePEYwTwgWcLsZDYZMzuzzEMIS/7BiwdFvPo/3vwbJ8keNLGgoajqprsrSjnTxve/vZXVtfWNzcJWcXtnd2+/dHDY1NIqQhtEcqnaEdaUM0EbhhlO26miOIk4bUWj26nfeqJKMykezDilYYIHgsWMYOOkZnY66QrbK5X9ij8DWiZBTsqQo94rfXX7ktiECkM41roT+KkJM6wMI5xOil2raYrJCA9ox1GBE6rDbHbtBJ07pY9iqVwJg2bq74kMJ1qPk8h1JtgM9aI3Ff/zOtbEN2HGRGoNFWS+KLYcGYmmr6M+U5QYPnYEE8XcrYgMscLEuICKLoRg8eVl0qxWgstK9f6qXDvO4yjACZzBBQRwDTW4gzo0gMAjPMMrvHnSe/HevY9564qXzxzBH3ifP3Cxjug=

AAACDHicbVC7TgMxEPSFVwivACWNIUGiiu6OAspINJRBIg8pF0V7ji+xYvss24cURfkAGn6FhgKEaPkAOv4G51FAwlqWxjOzWu/EijNjff/by62tb2xu5bcLO7t7+wfFw6OGSTNNaJ2kPNWtGAzlTNK6ZZbTltIURMxpMx7eTPXmA9WGpfLejhTtCOhLljAC1lHdYqkcDUEp6AbRqTsi45YJULPHXAjLzuVX/FnhVRAsQAktqtYtfkW9lGSCSks4GNMOfGU7Y9CWEU4nhSgzVAEZQp+2HZQgqOmMZ8tM8LljejhJtbvS4hn7u2MMwpiRiJ1TgB2YZW1K/qe1M5tcd8ZMqsxSSeaDkoxjm+JpMrjHNCWWjxwAopn7KyYD0ECsy6/gQgiWV14FjbASXFbCu7BUxYs48ugEnaELFKArVEW3qIbqiKBH9Ixe0Zv35L14797H3JrzFj3H6E95nz93upnd  !Unit !Unit ⌘AAAB63icbVBNS8NAEN3Ur1q/qh69LBbBU0mqoMeCF48V7Ae0oWy2k3bp7ibsToQS+he8eFDEq3/Im//GpM1BWx8MPN6bYWZeEEth0XW/ndLG5tb2Tnm3srd/cHhUPT7p2CgxHNo8kpHpBcyCFBraKFBCLzbAVCChG0zvcr/7BMaKSD/iLAZfsbEWoeAMc2kAyIbVmlt3F6DrxCtIjRRoDatfg1HEEwUauWTW9j03Rj9lBgWXMK8MEgsx41M2hn5GNVNg/XRx65xeZMqIhpHJSiNdqL8nUqasnakg61QMJ3bVy8X/vH6C4a2fCh0nCJovF4WJpBjR/HE6EgY4yllGGDciu5XyCTOMYxZPJQvBW315nXQade+q3ni4rjVpEUeZnJFzckk8ckOa5J60SJtwMiHP5JW8Ocp5cd6dj2VrySlmTskfOJ8//+eOGg== 1( 2 !⌫   Cell

Figure 6 Connection of edges by G : Λ Γ where Λ and Γ are the set of open incoming ports and outgoing ports respectively.→ They are also called the incoming and outgoing interfaces. Ports are typed (θ ::= ν κ), with either linear types ν ::= Int Unit κ ¨ | | | κ or qualified types κ ::= !ν Cell. We also denote qualified base types as η ::= !Int !Unit !Cell. Adjacent ports| have the same types, to be coherent with the wire homeomorphism.| | We often refer to a node using their labels, for example, we say a λ-node for a node labelled by λ. Some labels are used to indicate nodes that interpret calculus constructs: λ-node (abstraction), @-node (application), n-node (constants), s-node (step), p-node (peek), d-node (dereference), r-node (root dependency), m-node (memory cell creation), $-node (arithmetic operations), if-node (conditionals), µ-node (recursion), a-node (assignment) and l-node (link). Some nodes do not correspond to a syntactic construct but are created at runtime to represent dataflow graphs: n -node (memory cell). Finally the !-node, ?-node and C-node (contraction) are markers{ } used to guide sub-graph copying. These infrastructure nodes are conceptually derived from linear logic and the Geometry of Interaction (GoI) interpretation of proofs in linear logic, particularly as used in abstract token machines for GoI. The connection of edges via nodes must satisfies the typings in figure 6. When drawing graphs, certain diagrammatic conventions are employed. … Ports are not represented explicitly and = = … = … their labels are only shown when they … … … are not obvious. An edge with a bar at its tail represents zero or more ports, while Figure 7 Drawing conventions a double-stroke edge represents a bunch of the same nodes and ports in parallel (figure 7). We first define the translation from type judgement of a term to graphs infigure8 with op any unary and op0 any binary operator. The rules essentially construct the abstract syntax graph in the way discussed earlier: joining free-variable ports via contractions, looping free-variable back to the binders, inserting boxes around value- sub-graphs, adding linear logic token management nodes (!, ?). Note that all operations are eta-expanded, so, for example, instead of having just a + node in the graph we have a sub-graph corresponding to λx.λy.x + y. Finally, the C node with no in-ports is

12:10 Steven W.T. Cheung, Dan R. Ghica, and Koko Muroya

[[ ,x: ⌧ u : ⌧ 0]] AAACD3icbVDLSsNAFJ3UV42vqhvBzdTiYyElqYLiquBClwq2FpJQbibTduhMEmYmYin+gRt/xY0LRdy6deffOK1ZqPXAhTPn3Mvce8KUM6Ud59MqTE3PzM4V5+2FxaXlldLqWlMlmSS0QRKeyFYIinIW04ZmmtNWKimIkNPrsH868q9vqFQsia/0IKWBgG7MOoyANlK7tOP5ZQ/b/hkIAfu3J76GzL+JQPVwNn7s2oFfDtqlilN1xsCTxM1JBeW4aJc+/CghmaCxJhyU8lwn1cEQpGaE0zvbzxRNgfShSz1DYxBUBcPxPXd42ygR7iTSVKzxWP05MQSh1ECEplOA7qm/3kj8z/My3TkOhixOM01j8v1RJ+NYJ3gUDo6YpETzgSFAJDO7YtIDCUSbCG0Tgvv35EnSrFXdg2rt8rBS38jjKKJNtIX2kIuOUB2dowvUQATdo0f0jF6sB+vJerXevlsLVj6zjn7Bev8Ct02acA== ` [[ t0 : ⌧ ⌧ 0]] [[ t : ⌧]]

AAACGHicbVDLSgNBEJz1GddX1IvgZTSInuJuFBRPggc9RjAq7C6hdzJJhszsLjO9kRDyGV78FS8eFPHqzb9x8jj4KmioqepmuivOpDDoeZ/O1PTM7Nx8YcFdXFpeWS2urd+YNNeM11gqU30Xg+FSJLyGAiW/yzQHFUt+G3fOh/5tl2sj0uQaexmPFLQS0RQM0Er14kEQbgfUDS9AKQi7DTBtinunIUIeatFqI2id3g+fe24Ubkf1YskreyPQv8SfkBKZoFovfoSNlOWKJ8gkGBP4XoZRHzQKJvnADXPDM2AdaPHA0gQUN1F/dNiA7lqlQZuptpUgHanfJ/qgjOmp2HYqwLb57Q3F/7wgx+ZJ1BdJliNP2PijZi4ppnSYEm0IzRnKniXAtLC7UtYGDQxtlq4Nwf998l9yUyn7h+XK1VHpbHMSR4FskR2yT3xyTM7IJamSGmHkgTyRF/LqPDrPzpvzPm6dciYzG+QHnI8vhrOetw== ` ! AAACB3icbVBNS8NAEN34WeNX1IsgyNYieCpJFRRPBQ96VLBaSEKZbLft4m4SdidCKd68+Fe8eFDEq3/Bm//Gbe1Bqw8GHu/NMDMvyaUw6PufztT0zOzcfGnBXVxaXln11tavTFZoxhssk5luJmC4FClvoEDJm7nmoBLJr5Obk6F/fcu1EVl6if2cxwq6qegIBmillrcdRuWQutEpKAXRbRtMj+JxhFC4cVSOW17Fr/oj0L8kGJMKGeO85X1E7YwViqfIJBgTBn6O8QA0Cib5nRsVhufAbqDLQ0tTUNzEg9Efd3TXKm3aybStFOlI/TkxAGVMXyW2UwH2zKQ3FP/zwgI7R/FApHmBPGXfizqFpJjRYSi0LTRnKPuWANPC3kpZDzQwtNG5NoRg8uW/5KpWDfartYuDSn1zHEeJbJEdskcCckjq5IyckwZh5J48kmfy4jw4T86r8/bdOuWMZzbILzjvXyctl3Q= ` Γ λx.u : τ τ0 = Γ t0 t : τ0 = J ` → K J ` K AAAB7nicbVDLSsNAFL2pr1pfVZduBovgqiRV0GXBjcsK9gFtKJPJTTt0MgkzE6GEfoQbF4q49Xvc+TdO2yy09cDA4ZxzmXtPkAqujet+O6WNza3tnfJuZW//4PCoenzS0UmmGLZZIhLVC6hGwSW2DTcCe6lCGgcCu8Hkbu53n1BpnshHM03Rj+lI8ogzaqzUHQgbDemwWnPr7gJknXgFqUGB1rD6NQgTlsUoDRNU677npsbPqTKcCZxVBpnGlLIJHWHfUklj1H6+WHdGLqwSkihR9klDFurviZzGWk/jwCZjasZ61ZuL/3n9zES3fs5lmhmUbPlRlAliEjK/nYRcITNiagllittdCRtTRZmxDVVsCd7qyeuk06h7V/XGw3WtSYo6ynAG53AJHtxAE+6hBW1gMIFneIU3J3VenHfnYxktOcXMKfyB8/kDM9mPXw==

@AAAB6HicbVBNS8NAEJ3Ur1q/qh69LBbBU0mqoMeCF48t2A9oQ9lsJ+3azSbsboQS+gu8eFDEqz/Jm//GbZuDtj4YeLw3w8y8IBFcG9f9dgobm1vbO8Xd0t7+weFR+fikreNUMWyxWMSqG1CNgktsGW4EdhOFNAoEdoLJ3dzvPKHSPJYPZpqgH9GR5CFn1FipWR+UK27VXYCsEy8nFcjRGJS/+sOYpRFKwwTVuue5ifEzqgxnAmelfqoxoWxCR9izVNIItZ8tDp2RC6sMSRgrW9KQhfp7IqOR1tMosJ0RNWO96s3F/7xeasJbP+MySQ1KtlwUpoKYmMy/JkOukBkxtYQyxe2thI2poszYbEo2BG/15XXSrlW9q2qteV2pkzyOIpzBOVyCBzdQh3toQAsYIDzDK7w5j86L8+58LFsLTj5zCn/gfP4AiG2Mpg==

[[ ,f : ⌧ ⌧ 0 t : ⌧ ⌧ 0]] AAACIHicbVBNS8NAEN34WeNX1YvgZWsRPUhJVKh4EjzoUcGqkIQy2W7s4m4SdieFUvpTvPhXvHhQRG/6a9zWHurHg2Ee782wOy/OpTDoeR/OxOTU9Mxsac6dX1hcWi6vrF6ZrNCMN1gmM30Tg+FSpLyBAiW/yTUHFUt+Hd+dDPzrDtdGZOkldnMeKbhNRSIYoJWa5XoQVgLqhqegFOwmRyFCEWI2aNthpwWmTZEe0XHZjcJK1CxXvZo3BP1L/BGpkhHOm+X3sJWxQvEUmQRjAt/LMeqBRsEk77thYXgO7A5ueWBpCoqbqDc8sE+3rNKiSaZtpUiH6vhGD5QxXRXbSQXYNr+9gfifFxSYHEY9keYF8pR9P5QUkmJGB2nRltCcoexaAkwL+1fK2qCBoc3UtSH4v0/+S672av5+be/ioHq8PoqjRDbIJtkhPqmTY3JGzkmDMHJPHskzeXEenCfn1Xn7Hp1wRjtr5Aeczy+FlaE4 ! ` !

Γ , f : τ τ rec f .t : τ τ Γ , x : τ x : τ AAAB6HicbVBNS8NAEJ34WetX1aOXxSJ4KkkV9FjoxWML9gPaUDbbSbt2swm7G6GE/gIvHhTx6k/y5r9x2+agrQ8GHu/NMDMvSATXxnW/nY3Nre2d3cJecf/g8Oi4dHLa1nGqGLZYLGLVDahGwSW2DDcCu4lCGgUCO8GkPvc7T6g0j+WDmSboR3QkecgZNVZq1gelsltxFyDrxMtJGXI0BqWv/jBmaYTSMEG17nluYvyMKsOZwFmxn2pMKJvQEfYslTRC7WeLQ2fk0ipDEsbKljRkof6eyGik9TQKbGdEzVivenPxP6+XmvDOz7hMUoOSLReFqSAmJvOvyZArZEZMLaFMcXsrYWOqKDM2m6INwVt9eZ20qxXvulJt3pRrJI+jAOdwAVfgwS3U4B4a0AIGCM/wCm/Oo/PivDsfy9YNJ585gz9wPn8AjPmMqQ== C

0 0 = AAAB6nicbVDLSgNBEOz1GeMr6tHLYBA8hd0o6DHgxWNE84BkCbOT2WTIzOwy0yuEkE/w4kERr36RN//GSbIHTSxoKKq66e6KUiks+v63t7a+sbm1Xdgp7u7tHxyWjo6bNskM4w2WyMS0I2q5FJo3UKDk7dRwqiLJW9Hodua3nrixItGPOE55qOhAi1gwik566KqsVyr7FX8OskqCnJQhR71X+ur2E5YprpFJam0n8FMMJ9SgYJJPi93M8pSyER3wjqOaKm7DyfzUKTl3Sp/EiXGlkczV3xMTqqwdq8h1KopDu+zNxP+8TobxTTgROs2Qa7ZYFGeSYEJmf5O+MJyhHDtCmRHuVsKG1FCGLp2iCyFYfnmVNKuV4LJSvb8q10geRwFO4QwuIIBrqMEd1KEBDAbwDK/w5knvxXv3Phata14+cwJ/4H3+AFRyjbg= µ = J → ` → K J ` K

[[ u :Int]] [[ t1 : ]] [[ t2 : ]] AAAB83icbVDLSsNAFJ3UV62vqks3g0VwVZIq6LLgxmUF+4AmlMnkph06mYR5CCX0N9y4UMStP+POv3HSZqGtBwYO59zDvXPCjDOlXffbqWxsbm3vVHdre/sHh0f145OeSo2k0KUpT+UgJAo4E9DVTHMYZBJIEnLoh9O7wu8/gVQsFY96lkGQkLFgMaNEW8n3jYhAFmEsRvWG23QXwOvEK0kDleiM6l9+lFKTgNCUE6WGnpvpICdSM8phXvONgozQKRnD0FJBElBBvrh5ji+sEuE4lfYJjRfq70ROEqVmSWgnE6InatUrxP+8odHxbZAzkRkNgi4XxYZjneKiABwxCVTzmSWESmZvxXRCJKHa1lSzJXirX14nvVbTu2q2Hq4bbVzWUUVn6BxdIg/doDa6Rx3URRRl6Bm9ojfHOC/Ou/OxHK04ZeYU/YHz+QPzxpGE n AAACEXicbVC7SgNBFJ2Nr7i+ojaCzWgQrMKuCopVwELtIpgH7C7h7mSSDJmZXWZmhbDkF2z8FRsLRWzt7PwbJ4/C14ELh3Pu5d574pQzbTzv0ynMzS8sLhWX3ZXVtfWN0uZWQyeZIrROEp6oVgyaciZp3TDDaStVFETMaTMeXIz95h1VmiXy1gxTGgnoSdZlBIyV2qXDINwLsBteghAQ3nVA93GGz3EowPSVyK+lGblRuBe1S2Wv4k2A/xJ/Rspohlq79BF2EpIJKg3hoHXge6mJclCGEU5HbphpmgIZQI8GlkoQVEf55KMRPrBKB3cTZUsaPFG/T+QgtB6K2HaOD9W/vbH4nxdkpnsW5UymmaGSTBd1M45Ngsfx4A5TlBg+tASIYvZWTPqggBgbomtD8H+//Jc0jir+ceXo5qRc3ZnFUUS7aB8dIh+doiq6QjVURwTdo0f0jF6cB+fJeXXepq0FZzazjX7Aef8Ckdibew== ` AAACDXicbVDLSsNAFJ3UV42vqBvBzdQquCpJFRRXBRe6rGAfkIRyM522Q2eSMDMplNIfcOOvuHGhiFv37vwbp4+FVg9cOJxzL/feE6WcKe26X1ZuaXlldS2/bm9sbm3vOLt7dZVkktAaSXgimxEoyllMa5ppTpuppCAiThtR/3riNwZUKpbE93qY0lBAN2YdRkAbqeUc+0HBx3ZwA0JAMGiD6mHd8vAVDroTyQ6DQthyim7JnQL/Jd6cFNEc1ZbzGbQTkgkaa8JBKd9zUx2OQGpGOB3bQaZoCqQPXeobGoOgKhxNvxnjE6O0cSeRpmKNp+rPiREIpYYiMp0CdE8tehPxP8/PdOcyHLE4zTSNyWxRJ+NYJ3gSDW4zSYnmQ0OASGZuxaQHEog2AdomBG/x5b+kXi55Z6Xy3XmxcjCPI48O0RE6RR66QBV0i6qohgh6QE/oBb1aj9az9Wa9z1pz1nxmH/2C9fENlVWZOQ== ` AAACDXicbVDLSsNAFJ3UV42vqBvBzdQquCpJFRRXBRe6rGAfkIRyM522Q2eSMDMplNIfcOOvuHGhiFv37vwbp4+FVg9cOJxzL/feE6WcKe26X1ZuaXlldS2/bm9sbm3vOLt7dZVkktAaSXgimxEoyllMa5ppTpuppCAiThtR/3riNwZUKpbE93qY0lBAN2YdRkAbqeUc+0HBx3ZwA0JAMGiD6mHdKuMrHHQnkh0GhbDlFN2SOwX+S7w5KaI5qi3nM2gnJBM01oSDUr7npjocgdSMcDq2g0zRFEgfutQ3NAZBVTiafjPGJ0Zp404iTcUaT9WfEyMQSg1FZDoF6J5a9Cbif56f6c5lOGJxmmkak9miTsaxTvAkGtxmkhLNh4YAkczcikkPJBBtArRNCN7iy39JvVzyzkrlu/Ni5WAeRx4doiN0ijx0gSroFlVRDRH0gJ7QC3q1Hq1n6816n7XmrPnMPvoF6+MblueZOg== ` Γ if u then t1 else t2 : γ = Γ n : Int =

AAAB/nicbVC7SgNBFJ2NrxhfUUubwSBYSNiNhXYGbCyjmAckS5idnU2GzGOZmRWWJWBnY6ufYCe2/oq9YOMP2Dl5FCbxwIXDOfdy7z1BzKg2rvvh5JaWV1bX8uuFjc2t7Z3i7l5Dy0RhUseSSdUKkCaMClI31DDSihVBPGCkGQwuR37zjihNpbg1aUx8jnqCRhQjY6UbGXeLJbfsjgEXiTclpYufB/p98klq3eJXJ5Q44UQYzJDWbc+NjZ8hZShmZFjoJJrECA9Qj7QtFYgT7WfjS4fwyCohjKSyJQwcq38nMsS1TnlgOzkyfT3vjcT/vHZionM/oyJODBF4sihKGDQSjt6GIVUEG5ZagrCi9laI+0ghbGw4M1u04UilKhzaZLz5HBZJo1L2TsuVa7dUhWCCPDgAh+AYeOAMVMEVqIE6wCACj+AJPDv3zovz6rxNWnPOdGYfzMB5/wU2rJs1 op

Γ op : τ = Γ op0 : τ =

AAAB7nicbVDLSsNAFL2pr1pfVZduBovgqiRV0GXBjcsK9gFtKJPJTTt0MgkzE6GEfoQbF4q49Xvc+TdO2yy09cDA4ZxzmXtPkAqujet+O6WNza3tnfJuZW//4PCoenzS0UmmGLZZIhLVC6hGwSW2DTcCe6lCGgcCu8Hkbu53n1BpnshHM03Rj+lI8ogzaqzUHQgbDemwWnPr7gJknXgFqUGB1rD6NQgTlsUoDRNU677npsbPqTKcCZxVBpnGlLIJHWHfUklj1H6+WHdGLqwSkihR9klDFurviZzGWk/jwCZjasZ61ZuL/3n9zES3fs5lmhmUbPlRlAliEjK/nYRcITNiagllittdCRtTRZmxDVVsCd7qyeuk06h7V/XGw3WtSYo6ynAG53AJHtxAE+6hBW1gMIFneIU3J3VenHfnYxktOcXMKfyB8/kDM9mPXw== AAAB7nicbVDLSsNAFL2pr1pfVZduBovgqiRV0GXBjcsK9gFtKJPJTTt0MgkzE6GEfoQbF4q49Xvc+TdO2yy09cDA4ZxzmXtPkAqujet+O6WNza3tnfJuZW//4PCoenzS0UmmGLZZIhLVC6hGwSW2DTcCe6lCGgcCu8Hkbu53n1BpnshHM03Rj+lI8ogzaqzUHQgbDemwWnPr7gJknXgFqUGB1rD6NQgTlsUoDRNU677npsbPqTKcCZxVBpnGlLIJHWHfUklj1H6+WHdGLqwSkihR9klDFurviZzGWk/jwCZjasZ61ZuL/3n9zES3fs5lmhmUbPlRlAliEjK/nYRcITNiagllittdCRtTRZmxDVVsCd7qyeuk06h7V/XGw3WtSYo6ynAG53AJHtxAE+6hBW1gMIFneIU3J3VenHfnYxktOcXMKfyB8/kDM9mPXw==

AAAB6HicbVBNS8NAEJ3Ur1q/qh69rBbBU0mqoMeCF48t2FpoQ9lsJ+3azSbsboQS+gu8eFDEqz/Jm//GbZuDtj4YeLw3w8y8IBFcG9f9dgpr6xubW8Xt0s7u3v5B+fCoreNUMWyxWMSqE1CNgktsGW4EdhKFNAoEPgTj25n/8IRK81jem0mCfkSHkoecUWOl5mm/XHGr7hxklXg5qUCORr/81RvELI1QGiao1l3PTYyfUWU4Ezgt9VKNCWVjOsSupZJGqP1sfuiUnFtlQMJY2ZKGzNXfExmNtJ5Ege2MqBnpZW8m/ud1UxPe+BmXSWpQssWiMBXExGT2NRlwhcyIiSWUKW5vJWxEFWXGZlOyIXjLL6+Sdq3qXVZrzatKneRxFOEEzuACPLiGOtxBA1rAAOEZXuHNeXRenHfnY9FacPKZY/gD5/MHWXGMhw== C AAAB6HicbVBNS8NAEJ34WetX1aOXxSJ4KkkV9FjoxWML9gPaUDbbSbt2swm7G6GE/gIvHhTx6k/y5r9x2+agrQ8GHu/NMDMvSATXxnW/nY3Nre2d3cJecf/g8Oi4dHLa1nGqGLZYLGLVDahGwSW2DDcCu4lCGgUCO8GkPvc7T6g0j+WDmSboR3QkecgZNVZq1gelsltxFyDrxMtJGXI0BqWv/jBmaYTSMEG17nluYvyMKsOZwFmxn2pMKJvQEfYslTRC7WeLQ2fk0ipDEsbKljRkof6eyGik9TQKbGdEzVivenPxP6+XmvDOz7hMUoOSLReFqSAmJvOvyZArZEZMLaFMcXsrYWOqKDM2m6INwVt9eZ20qxXvulJt3pRrJI+jAOdwAVfgwS3U4B4a0AIGCM/wCm/Oo/PivDsfy9YNJ585gz9wPn8AjPmMqQ== ! C AAAB6HicbVBNS8NAEJ3Ur1q/qh69rBbBU0mqoMeCF48t2FpoQ9lsJ+3azSbsboQS+gu8eFDEqz/Jm//GbZuDtj4YeLw3w8y8IBFcG9f9dgpr6xubW8Xt0s7u3v5B+fCoreNUMWyxWMSqE1CNgktsGW4EdhKFNAoEPgTj25n/8IRK81jem0mCfkSHkoecUWOl5mm/XHGr7hxklXg5qUCORr/81RvELI1QGiao1l3PTYyfUWU4Ezgt9VKNCWVjOsSupZJGqP1sfuiUnFtlQMJY2ZKGzNXfExmNtJ5Ege2MqBnpZW8m/ud1UxPe+BmXSWpQssWiMBXExGT2NRlwhcyIiSWUKW5vJWxEFWXGZlOyIXjLL6+Sdq3qXVZrzatKneRxFOEEzuACPLiGOtxBA1rAAOEZXuHNeXRenHfnY9FacPKZY/gD5/MHWXGMhw== !

Figure 8 Representation of terms the degenerate contraction (usually referred to as ‘weakening’) used to mark unused variables in a subterm.

3.3 Machine states

As explained, the machine execution is given by an evaluation token traversing the graph and rewriting it. To manage the process the machine also uses data, as defined below. We call this data ‘evaluation token data’ as it can be thought of as data carried by the token.

12:11 Transparent Synchronous Dataflow

Definition 3.1 (Evaluation tokens). For any graph G, the state of an evaluation token (e, d, f , S, B) consists of a port e PortG indicating the token position, a direction d, a rewrite flag, f a computation stack∈ S and a box stack B with

d ::= ↑ | ↓ f ::= @ if C ! µ m p l(i) a(n, i) r(i) sp s | | | | | | | | | | | | S ::= ? : S (λ, ) : S (n, ) : S (n, g) : S (n, i) : S ((), ) : S if0 : S if1 : S | | − | − | | | − | | B ::= i : B | where i PortG. ∈ In the definition above e denotes the current position of the token. The rewrite flag determines the possible graph rewriting. The computation stack tracks the intermediate results of the evaluation and the box stack tracks duplication of values. Together the two stacks guide the transition of token. In particular the token asks the value of a graph by having ? : S as its computation stack. After traversing the graph it could return either (λ, ) : S, (n, r) : S or ((), ) : S. The first part (λ,n,()) is the return value − − while the second part indicates whether it is a cell (i PortG with i denoting the in-port of the cell), a graph (g) or a normal value ( ). ∈ − Definition 3.2 (Machine states). A machine state (G, δ, P) is a triplet consisting of a graph G, an eval token δ (hereinafter referred to as the main token) and a set of eval tokens P (hereinafter referred to as the set of prop tokens) that are used during propagation.

We define a binary relation on machine states called transitions (G, δ, P) (G0, δ0, P0) which includes normal pass and rewrite transitions. We group the transitions7→ into pass transitions in which only the token changes, and rewrite transitions in which the underlying graph may change.

3.4 Pass rules

The pass transitions are given in table 1. The token is at a distin- guished port in the graph and the node column represents the

AAAB6nicbVBNS8NAEJ3Ur1q/qh69LBbBU0lqQY8FLx4r2g9oQ9lsJ+3SzSbsboQS+hO8eFDEq7/Im//GbZuDtj4YeLw3w8y8IBFcG9f9dgobm1vbO8Xd0t7+weFR+fikreNUMWyxWMSqG1CNgktsGW4EdhOFNAoEdoLJ7dzvPKHSPJaPZpqgH9GR5CFn1FjpgQ/cQbniVt0FyDrxclKBHM1B+as/jFkaoTRMUK17npsYP6PKcCZwVuqnGhPKJnSEPUsljVD72eLUGbmwypCEsbIlDVmovycyGmk9jQLbGVEz1qveXPzP66UmvPEzLpPUoGTLRWEqiInJ/G8y5AqZEVNLKFPc3krYmCrKjE2nZEPwVl9eJ+1a1buq1u7rlQbJ4yjCGZzDJXhwDQ24gya0gMEInuEV3hzhvDjvzseyteDkM6fwB87nD+pXjXI= i0 oAAAB6nicbVDLSgNBEOz1GeMr6tHLYBA8hd0o6DHgxWNE84BkCbOT3mTI7MwyMyuEkE/w4kERr36RN//GSbIHTSxoKKq66e6KUsGN9f1vb219Y3Nru7BT3N3bPzgsHR03jco0wwZTQul2RA0KLrFhuRXYTjXSJBLYika3M7/1hNpwJR/tOMUwoQPJY86oddKD6vm9Utmv+HOQVRLkpAw56r3SV7evWJagtExQYzqBn9pwQrXlTOC02M0MppSN6AA7jkqaoAkn81On5NwpfRIr7UpaMld/T0xoYsw4iVxnQu3QLHsz8T+vk9n4JpxwmWYWJVssijNBrCKzv0mfa2RWjB2hTHN3K2FDqimzLp2iCyFYfnmVNKuV4LJSvb8q10geRwFO4QwuIIBrqMEd1KEBDAbwDK/w5gnvxXv3Phata14+cwJ/4H3+APN7jXg= 0 label of one of the two nodes of the port. The second column (‘e’)

represents whether it is an incoming (i) or an outgoing (o) port. AAAB7nicbVDLSsNAFL2pr1pfVZduBovgqiRV0GXBjcsK9gFtKJPJTTt0MgkzE6GEfoQbF4q49Xvc+TdO2yy09cDA4ZxzmXtPkAqujet+O6WNza3tnfJuZW//4PCoenzS0UmmGLZZIhLVC6hGwSW2DTcCe6lCGgcCu8Hkbu53n1BpnshHM03Rj+lI8ogzaqzUHQgbDemwWnPr7gJknXgFqUGB1rD6NQgTlsUoDRNU677npsbPqTKcCZxVBpnGlLIJHWHfUklj1H6+WHdGLqwSkihR9klDFurviZzGWk/jwCZjasZ61ZuL/3n9zES3fs5lmhmUbPlRlAliEjK/nYRcITNiagllittdCRtTRZmxDVVsCd7qyeuk06h7V/XGw3WtSYo6ynAG53AJHtxAE+6hBW1gMIFneIU3J3VenHfnYxktOcXMKfyB8/kDM9mPXw== We labelled the ports by its left-to-right order from zero as in figure 9. The next three columns represent the state of the direction AAAB6nicbVBNS8NAEJ3Ur1q/qh69LBbBU0lqQY8FLx4r2g9oQ9lsJ+3SzSbsboQS+hO8eFDEq7/Im//GbZuDtj4YeLw3w8y8IBFcG9f9dgobm1vbO8Xd0t7+weFR+fikreNUMWyxWMSqG1CNgktsGW4EdhOFNAoEdoLJ7dzvPKHSPJaPZpqgH9GR5CFn1FjpgQ+8QbniVt0FyDrxclKBHM1B+as/jFkaoTRMUK17npsYP6PKcCZwVuqnGhPKJnSEPUsljVD72eLUGbmwypCEsbIlDVmovycyGmk9jQLbGVEz1qveXPzP66UmvPEzLpPUoGTLRWEqiInJ/G8y5AqZEVNLKFPc3krYmCrKjE2nZEPwVl9eJ+1a1buq1u7rlQbJ4yjCGZzDJXhwDQ24gya0gMEInuEV3hzhvDjvzseyteDkM6fwB87nD+vbjXM= i1 d, flag f , and stack S. The next column represents the new port e visited by the token, relative to the node. The final three columns Figure 9 represent the new values of the direction, flag, and stack.

Node λ: If the token is at the first incoming port i1 of a λ node travelling along the direction of the edge d = the token will reverse directions d = and the top of the stack will be replaced↑ by information that a λ node has been↓ encountered by placing (λ, ) at the top. For reasons of well-formedness a ? must have been at that op of S−. This rule reflects the fact that a λ-term is a value which requires no further evaluation.

12:12 Steven W.T. Cheung, Dan R. Ghica, and Koko Muroya

Node @: If the token reaches the sole incoming port i0 of an application node it will pass through and move to its first outgoing port o1 (right out-port), reflecting the right-to-left call-by-value evaluation. As it returns d = along the same port o1 it is ↓ passed to the zeroth outgoing port o0 (left out-port) with changed direction d = ↑ and the top of the stack become ?. Finally as it returns d = on the same port it ↓ is passed to the incoming port i0 with d = in preparation for the rewrite corresponding to application. Node that it is expected↓ that the last value encountered on the left side was a lambda term, since the rule expects (λ, ) at the top. The − imminence of the rewrite rule is indicated by the rewrite flag f = @. Nodes n, (): These nodes represent values so their behaviour is quite similar to that of the λ node, reflecting the token and placing the value on S. Operation nodes These nodes behave similarly to @. Incoming-port tokens are propagated to the outgoing port(s). When they come back along the outgoing port the behaviour is different according to whether they are unary or binary operators. If they are unary the token is passed to the incoming port and the rewrite flag f is used to indicate an imminent rewrite. If they are binary then the second outgoing port is visited first. Node if: This node behaves like a ternary operator, except that after returning from the first outgoing edge the top of the stack is inspected. Node µ: The recursion node immediately prepares the machine for a rewrite by changing the flag to f = µ. Node !: This node, also found in conventional GOI abstract machines, indicates that a box is about to be processed. The rewrite rule about to be triggered is indicated by the flag becoming f = !. Node n : The cell storing value n is dealt with almost as a standard integer value. { } The only difference is that the port io is also placed on top of S along with the value n, to be possibly used by datflow graph operations. Node C: Contraction nodes use the other stack, the box-stack, to remember along which of the several incoming ports a token arrived so that it can return to the same port. Moreover, the incoming port prepares a rewrite f = C, essentially the copying of the shared term (represented as a subgraph). Note that certain nodes, such as ?, have no associated rules because the token is never supposed to reach them.

3.5 Rewrite rules

The pass rules only serve to set the scene for the rewrite transitions, which are given in figure 10. The Beta rule: The essential computational rule of the lambda calculus is the removal of the abstraction-application pair. The second outgoing port of the application node @ is connected to the argument, which is now re-wired to the first argument of the subgraph G representing the function body. This is a ‘small’ beta law since

12:13 Transparent Synchronous Dataflow

Table 1 Pass transitions

node e d f S e d f S 7→ λ i1 ?:S i1 (λ, ):S ↑ ↓ − @ i0 S o1 S ↑ ↑ @ o1 X:S o0 ?:S ↓ ↑ @ o0 (λ, ):S i0 @ ?:S ↓ − ↑ n i0 ?:S i0 (n, ):S ↑ ↓ − () i0 ?:S i0 ((), ):S ↑ ↓ − For ω p, d, r, m (unary operations): ∈ ω i0 S o0 S ↑ ↑ p o0 (n, x):S i0 p (n, ):S ↓ ↓ − r o0 (n, i):S i0 r(i) (n, ):S ↓ ↓ − m o0 (n, x):S i0 m (n, ):S ↓ ↓ − For # $ a, l (binary operations): ∈ ∪ # i0 S o1 S ↑ ↑ # o1 S o0 ?:S ↓ ↑ $ o0 (m, ) : (n, ):S i0 $ ($ m n, ):S ↓ − − ↓ − a o0 (m, i) : (n, x):S i0 a(n, i) ((), ):S ↓ ↓ − l o0 (m, i) : (n, x):S i0 l(i) ((), ):S ↓ ↓ − if i0 S o0 S ↑ ↑ if o0 (0, ):S o1 if ?:S ↓ − ↑ if o0 (n = 0, ):S o2 if ?:S ↓ 6 − ↑ if o1 S o2 ?:S ↓ ↑ µ i1 S i1 µ S ↑ ↑ ! i0 S o0 ! S ↑ ↑ ! o0 S i0 S ↓ ↓ n i0 ?:S i0 (n, i0):S { } ↑ ↓ where x , g ∈ {− }

node e d f S B e d f S B 7→ C ik SB o0 C S ik:B ↑ ↑ C o0 S ik:B ik SB ↓ ↓

12:14 Steven W.T. Cheung, Dan R. Ghica, and Koko Muroya

AAAB6HicbVBNS8NAEJ3Ur1q/qh69LBbBU0mqoMeCF48t2A9oQ9lsJ+3azSbsboQS+gu8eFDEqz/Jm//GbZuDtj4YeLw3w8y8IBFcG9f9dgobm1vbO8Xd0t7+weFR+fikreNUMWyxWMSqG1CNgktsGW4EdhOFNAoEdoLJ3dzvPKHSPJYPZpqgH9GR5CFn1FipWR+UK27VXYCsEy8nFcjRGJS/+sOYpRFKwwTVuue5ifEzqgxnAmelfqoxoWxCR9izVNIItZ8tDp2RC6sMSRgrW9KQhfp7IqOR1tMosJ0RNWO96s3F/7xeasJbP+MySQ1KtlwUpoKYmMy/JkOukBkxtYQyxe2thI2poszYbEo2BG/15XXSrlW9q2qteV2pkzyOIpzBOVyCBzdQh3toQAsYIDzDK7w5j86L8+58LFsLTj5zCn/gfP4AiG2Mpg==

ifAAAB8nicbVDLSsNAFL2pr1pfVZduBovgqiRV0GXBjcsK9gFtKJPppB06mYSZG6GEfoYbF4q49Wvc+TdO2iy09cDA4Zx7mXNPkEhh0HW/ndLG5tb2Tnm3srd/cHhUPT7pmDjVjLdZLGPdC6jhUijeRoGS9xLNaRRI3g2md7nffeLaiFg94izhfkTHSoSCUbRSfxBRnAjMRDgfVmtu3V2ArBOvIDUo0BpWvwajmKURV8gkNabvuQn6GdUomOTzyiA1PKFsSse8b6miETd+tog8JxdWGZEw1vYpJAv190ZGI2NmUWAn84hm1cvF/7x+iuGtnwmVpMgVW34UppJgTPL7yUhozlDOLKFMC5uVsAnVlKFtqWJL8FZPXiedRt27qjcermtNUtRRhjM4h0vw4AaacA8taAODGJ7hFd4cdF6cd+djOVpyip1T+APn8wfBZpF0 @ ifAAAB8nicbVDLSsNAFL2pr1pfVZduBovgqiRV0GXBjcsK9gFtKJPppB06mYSZG6GEfoYbF4q49Wvc+TdO2iy09cDA4Zx7mXNPkEhh0HW/ndLG5tb2Tnm3srd/cHhUPT7pmDjVjLdZLGPdC6jhUijeRoGS9xLNaRRI3g2md7nffeLaiFg94izhfkTHSoSCUbRSfxBRnAjMRDgfVmtu3V2ArBOvIDUo0BpWvwajmKURV8gkNabvuQn6GdUomOTzyiA1PKFsSse8b6miETd+tog8JxdWGZEw1vYpJAv190ZGI2NmUWAn84hm1cvF/7x+iuGtnwmVpMgVW34UppJgTPL7yUhozlDOLKFMC5uVsAnVlKFtqWJL8FZPXiedRt27qjcermtNUtRRhjM4h0vw4AaacA8taAODGJ7hFd4cdF6cd+djOVpyip1T+APn8wfBZpF0 C C C C

AAACA3icbVDLSsNAFJ34rPUVdSO6GSyCi1KSKuiy6MZlRfuAppTJdNIOnZmEmYlSQsCNv+LGhSJu/Ql3/o2TNgttPXDhcM693HuPHzGqtON8WwuLS8srq4W14vrG5ta2vbPbVGEsMWngkIWy7SNFGBWkoalmpB1JgrjPSMsfXWV+655IRUNxp8cR6XI0EDSgGGkj9ewDL46QlOFDOfE40kPJExqkafm2fNmzS07FmQDOEzcnJZCj3rO/vH6IY06Exgwp1XGdSHcTJDXFjKRFL1YkQniEBqRjqECcqG4y+SGFx0bpwyCUpoSGE/X3RIK4UmPum87sTjXrZeJ/XifWwUU3oSKKNRF4uiiIGdQhzAKBfSoJ1mxsCMKSmlshHiKJsDaxFU0I7uzL86RZrbinlerNWam2n8dRAIfgCJwAF5yDGrgGddAAGDyCZ/AK3qwn68V6tz6mrQtWPrMH/sD6/AEnHJey , if,S,B AAAB/3icbVDLSgMxFM3UV62vUUEEN8EiuChlpgq6LLpxWdE+oDOUTJppQzPJmGSUMnbhr7hxoYhbf8Odf2PazkJbD1w4nHMv994TxIwq7TjfVm5hcWl5Jb9aWFvf2Nyyt3caSiQSkzoWTMhWgBRhlJO6ppqRViwJigJGmsHgcuw374lUVPBbPYyJH6EepyHFSBupY+95SYykFA+l1FN3CZJkVLopXXTsolN2JoDzxM1IEWSodewvrytwEhGuMUNKtV0n1n6KpKaYkVHBSxSJER6gHmkbylFElJ9O7h/BI6N0YSikKa7hRP09kaJIqWEUmM4I6b6a9cbif1470eG5n1IeJ5pwPF0UJgxqAcdhwC6VBGs2NARhSc2tEPeRRFibyAomBHf25XnSqJTdk3Ll+rRY3c/iyIMDcAiOgQvOQBVcgRqoAwwewTN4BW/Wk/VivVsf09aclc3sgj+wPn8AxbOVyw== , ,S,B AAACA3icbVDLSsNAFJ34rPUVdSO6GSyCi1KSKuiy6MZlRfuAppTJdNIOnZmEmYlSQsCNv+LGhSJu/Ql3/o2TNgttPXDhcM693HuPHzGqtON8WwuLS8srq4W14vrG5ta2vbPbVGEsMWngkIWy7SNFGBWkoalmpB1JgrjPSMsfXWV+655IRUNxp8cR6XI0EDSgGGkj9ewDL46QlOFDOfE40kPJExqkafm2fNmzS07FmQDOEzcnJZCj3rO/vH6IY06Exgwp1XGdSHcTJDXFjKRFL1YkQniEBqRjqECcqG4y+SGFx0bpwyCUpoSGE/X3RIK4UmPum87sTjXrZeJ/XifWwUU3oSKKNRF4uiiIGdQhzAKBfSoJ1mxsCMKSmlshHiKJsDaxFU0I7uzL86RZrbinlerNWam2n8dRAIfgCJwAF5yDGrgGddAAGDyCZ/AK3qwn68V6tz6mrQtWPrMH/sD6/AEnHJey , if,S,B AAAB/3icbVDLSgMxFM3UV62vUUEEN8EiuChlpgq6LLpxWdE+oDOUTJppQzPJmGSUMnbhr7hxoYhbf8Odf2PazkJbD1w4nHMv994TxIwq7TjfVm5hcWl5Jb9aWFvf2Nyyt3caSiQSkzoWTMhWgBRhlJO6ppqRViwJigJGmsHgcuw374lUVPBbPYyJH6EepyHFSBupY+95SYykFA+l1FN3CZJkVLopXXTsolN2JoDzxM1IEWSodewvrytwEhGuMUNKtV0n1n6KpKaYkVHBSxSJER6gHmkbylFElJ9O7h/BI6N0YSikKa7hRP09kaJIqWEUmM4I6b6a9cbif1470eG5n1IeJ5pwPF0UJgxqAcdhwC6VBGs2NARhSc2tEPeRRFibyAomBHf25XnSqJTdk3Ll+rRY3c/iyIMDcAiOgQvOQBVcgRqoAwwewTN4BW/Wk/VivVsf09aclc3sgj+wPn8AxbOVyw== , ,S,B

AAAB/XicbVDLSsNAFJ3UV62v+FgIbgaL4KKUpAq6LLpxWdE+oAllMp20QyeZOA+lhuKvuHGhiFv/w51/47TNQlsPXDiccy/33hMkjErlON9WbmFxaXklv1pYW9/Y3LK3dxqSa4FJHXPGRStAkjAak7qiipFWIgiKAkaaweBy7DfviZCUx7dqmBA/Qr2YhhQjZaSOvefpBAnBH0qevNNIkNJN6aJjF52yMwGcJ25GiiBDrWN/eV2OdURihRmSsu06ifJTJBTFjIwKnpYkQXiAeqRtaIwiIv10cv0IHhmlC0MuTMUKTtTfEymKpBxGgemMkOrLWW8s/ue1tQrP/ZTGiVYkxtNFoWZQcTiOAnapIFixoSEIC2puhbiPBMLKBFYwIbizL8+TRqXsnpQr16fF6n4WRx4cgENwDFxwBqrgCtRAHWDwCJ7BK3iznqwX6936mLbmrGxmF/yB9fkD8YyUvw== , ,S,B AAAB+XicbVDLSgMxFL1TX7W+Rt0IboJFcFHKTBV0WXTjsqJ9QDuUTJppQzOZIcm0lKF/4saFIm79E3f+jWk7C209cOFwzr3JvcePOVPacb6t3Nr6xuZWfruws7u3f2AfHjVUlEhC6yTikWz5WFHOBK1rpjltxZLi0Oe06Q/vZn5zRKVikXjSk5h6Ie4LFjCCtZG6tt3pRWOBpYzGpWrpsXTbtYtO2ZkDrRI3I0XIUOvaX+YJkoRUaMKxUm3XibWXYqkZ4XRa6CSKxpgMcZ+2DRU4pMpL55tP0blReiiIpCmh0Vz9PZHiUKlJ6JvOEOuBWvZm4n9eO9HBjZcyESeaCrL4KEg40hGaxYB6TFKi+cQQTCQzuyIywBITbcIqmBDc5ZNXSaNSdi/LlYerYvUkiyMPp3AGF+DCNVThHmpQBwIjeIZXeLNS68V6tz4WrTkrmzmGP7A+fwBxOpK9 , @,S,B ⇤ ⇤ ⇤ # " " " " "

AAAB83icbVDLSsNAFJ3UV62vqks3g0VwVZIq6LLgxmUF+4AmlMnkph06mYR5CCX0N9y4UMStP+POv3HSZqGtBwYO59zDvXPCjDOlXffbqWxsbm3vVHdre/sHh0f145OeSo2k0KUpT+UgJAo4E9DVTHMYZBJIEnLoh9O7wu8/gVQsFY96lkGQkLFgMaNEW8n3jYhAFmEsRvWG23QXwOvEK0kDleiM6l9+lFKTgNCUE6WGnpvpICdSM8phXvONgozQKRnD0FJBElBBvrh5ji+sEuE4lfYJjRfq70ROEqVmSWgnE6InatUrxP+8odHxbZAzkRkNgi4XxYZjneKiABwxCVTzmSWESmZvxXRCJKHa1lSzJXirX14nvVbTu2q2Hq4bbVzWUUVn6BxdIg/doDa6Rx3URRRl6Bm9ojfHOC/Ou/OxHK04ZeYU/YHz+QPzxpGE n p m AAAB83icbVDLSsNAFJ3UV62vqks3g0VwVZIq6LLgxmUF+4AmlMnkph06mYR5CCX0N9y4UMStP+POv3HSZqGtBwYO59zDvXPCjDOlXffbqWxsbm3vVHdre/sHh0f145OeSo2k0KUpT+UgJAo4E9DVTHMYZBJIEnLoh9O7wu8/gVQsFY96lkGQkLFgMaNEW8n3jYhAFmEsRvWG23QXwOvEK0kDleiM6l9+lFKTgNCUE6WGnpvpICdSM8phXvONgozQKRnD0FJBElBBvrh5ji+sEuE4lfYJjRfq70ROEqVmSWgnE6InatUrxP+8odHxbZAzkRkNgi4XxYZjneKiABwxCVTzmSWESmZvxXRCJKHa1lSzJXirX14nvVbTu2q2Hq4bbVzWUUVn6BxdIg/doDa6Rx3URRRl6Bm9ojfHOC/Ou/OxHK04ZeYU/YHz+QPzxpGE n

AAAB6HicbVBNS8NAEJ3Ur1q/qh69LBbBU0mqoMeCF48t2A9oQ9lsJ+3azSbsboQS+gu8eFDEqz/Jm//GbZuDtj4YeLw3w8y8IBFcG9f9dgobm1vbO8Xd0t7+weFR+fikreNUMWyxWMSqG1CNgktsGW4EdhOFNAoEdoLJ3dzvPKHSPJYPZpqgH9GR5CFn1FipmQzKFbfqLkDWiZeTCuRoDMpf/WHM0gilYYJq3fPcxPgZVYYzgbNSP9WYUDahI+xZKmmE2s8Wh87IhVWGJIyVLWnIQv09kdFI62kU2M6ImrFe9ebif14vNeGtn3GZpAYlWy4KU0FMTOZfkyFXyIyYWkKZ4vZWwsZUUWZsNiUbgrf68jpp16reVbXWvK7USR5HEc7gHC7Bgxuowz00oAUMEJ7hFd6cR+fFeXc+lq0FJ585hT9wPn8A0S2M1g== p AAAB6HicbVBNS8NAEJ3Ur1q/qh69LBbBU0mqoMeCF48t2A9oQ9lsJ+3a3STsboQS+gu8eFDEqz/Jm//GbZuDtj4YeLw3w8y8IBFcG9f9dgobm1vbO8Xd0t7+weFR+fikreNUMWyxWMSqG1CNgkfYMtwI7CYKqQwEdoLJ3dzvPKHSPI4ezDRBX9JRxEPOqLFSUw7KFbfqLkDWiZeTCuRoDMpf/WHMUomRYYJq3fPcxPgZVYYzgbNSP9WYUDahI+xZGlGJ2s8Wh87IhVWGJIyVrciQhfp7IqNS66kMbKekZqxXvbn4n9dLTXjrZzxKUoMRWy4KU0FMTOZfkyFXyIyYWkKZ4vZWwsZUUWZsNiUbgrf68jpp16reVbXWvK7USR5HEc7gHC7Bgxuowz00oAUMEJ7hFd6cR+fFeXc+lq0FJ585hT9wPn8AzKGM0w== m n {AAAB+XicbVDLSsNAFL2pr1pfUTeCm8EiuCpJFXRZcOOygn1AE8pkMmmHTiZhZlIooX/ixoUibv0Td/6NkzYLbT1w4XDOvTP3niDlTGnH+bYqG5tb2zvV3dre/sHhkX180lVJJgntkIQnsh9gRTkTtKOZ5rSfSorjgNNeMLkv/N6USsUS8aRnKfVjPBIsYgRrIw1t28u9TIRUFg8g4c2Hdt1pOAugdeKWpA4l2kP7ywsTksVUaMKxUgPXSbWfY6kZ4XRe8zJFU0wmeEQHhgocU+Xni83n6NIoIYoSaUpotFB/T+Q4VmoWB6YzxnqsVr1C/M8bZDq683Mm0kxTQZYfRRlHOkFFDChkkhLNZ4ZgIpnZFZExlphoE1bNhOCunrxOus2Ge91oPt7UW2dlHFU4hwu4AhduoQUP0IYOEJjCM7zCm5VbL9a79bFsrVjlzCn8gfX5A6H8k4U= } s

AAAB6HicbVBNS8NAEJ3Ur1q/qh69LBbBU0mqoMeCF48t2A9oQ9lsJ+3azSbsboQS+gu8eFDEqz/Jm//GbZuDtj4YeLw3w8y8IBFcG9f9dgobm1vbO8Xd0t7+weFR+fikreNUMWyxWMSqG1CNgktsGW4EdhOFNAoEdoLJ3dzvPKHSPJYPZpqgH9GR5CFn1FipqQflilt1FyDrxMtJBXI0BuWv/jBmaYTSMEG17nluYvyMKsOZwFmpn2pMKJvQEfYslTRC7WeLQ2fkwipDEsbKljRkof6eyGik9TQKbGdEzVivenPxP6+XmvDWz7hMUoOSLReFqSAmJvOvyZArZEZMLaFMcXsrYWOqKDM2m5INwVt9eZ20a1XvqlprXlfqJI+jCGdwDpfgwQ3U4R4a0AIGCM/wCm/Oo/PivDsfy9aCk8+cwh84nz/VuYzZ

AAACC3icbVDLSgMxFM3UV62vqhvBTWgRKtQyUwXFVdGNy4r2Ae1QMmmmDc0kQ5KxlKF7N/6KGxeKuPUH3Pk3pu0stPVA4HDOfeQeL2RUadv+tlJLyyura+n1zMbm1vZOdnevrkQkMalhwYRsekgRRjmpaaoZaYaSoMBjpOENrid+44FIRQW/16OQuAHqcepTjLSROtlcuyuGHEkphsWwWGhHvEvkZBjkRXhyfHlXvOpk83bJngIuEicheZCg2sl+maE4CgjXmCGlWo4dajdGUlPMyDjTjhQJER6gHmkZylFAlBtPbxnDI6N0oS+keVzDqfq7I0aBUqPAM5UB0n01703E/7xWpP0LN6Y8jDTheLbIjxjUAk6CgV0qCdZsZAjCkpq/QtxHEmFt4suYEJz5kxdJvVxyTkvl27N85SCJIw0OQQ4UgAPOQQXcgCqoAQwewTN4BW/Wk/VivVsfs9KUlfTsgz+wPn8An+6ZVQ== AAACEXicbVBNSwJBGJ61L7Mvq0vQZUgCA5NdC4pOUpeORvkBKjI7vurg7Ow2M5uI+Be69Fe6dCiia7du/ZtmdQ+lPTDw8Dzvx7yPG3CmtG1/W4mFxaXlleRqam19Y3Mrvb1TUX4oKZSpz31Zc4kCzgSUNdMcaoEE4rkcqm7/KvKrDyAV88WdHgbQ9EhXsA6jRBuplc422v5AECn9Qa6h7kMiIZdthKINMhqJRQ4fH13c5i5b6YydtyfA88SJSQbFKLXSX2Y0DT0QmnKiVN2xA90cEakZ5TBONUIFAaF90oW6oYJ4oJqjyUVjfGiUNu740jyh8UT93TEinlJDzzWVHtE9NetF4n9ePdSd8+aIiSDUIOh0USfkWPs4ige3mQSq+dAQQiUzf8W0RySh2oSYMiE4syfPk0oh75zkCzenmeJeHEcS7aMDlEUOOkNFdI1KqIwoekTP6BW9WU/Wi/VufUxLE1bcs4v+wPr8AZ9nnA4= AAACC3icbVDLSgMxFM3UV62vqhvBTWgRKtQyUwXFVdGNy4r2Ae1QMmmmDU0yQ5KxlKF7N/6KGxeKuPUH3Pk3pu0stPVA4HDOfeQeL2RUadv+tlJLyyura+n1zMbm1vZOdnevroJIYlLDAQtk00OKMCpITVPNSDOUBHGPkYY3uJ74jQciFQ3EvR6FxOWoJ6hPMdJG6mRz7W4wFEjKYFjkxUI7El0iJ8OgKMKT48u74lUnm7dL9hRwkTgJyYME1U72ywzFESdCY4aUajl2qN0YSU0xI+NMO1IkRHiAeqRlqECcKDee3jKGR0bpQj+Q5gkNp+rvjhhxpUbcM5Uc6b6a9ybif14r0v6FG1MRRpoIPFvkRwzqAE6CgV0qCdZsZAjCkpq/QtxHEmFt4suYEJz5kxdJvVxyTkvl27N85SCJIw0OQQ4UgAPOQQXcgCqoAQwewTN4BW/Wk/VivVsfs9KUlfTsgz+wPn8AmyCZUg== AAACCnicbVDLSgMxFM3UV62vqhvBTbQIFcYyUwXFVdGNy4r2Ae1QMplMG5rJDEnGUkrXbvwVNy4UcesXuPNvzLSz0NYDgcM595F73IhRqSzr28gsLC4tr2RXc2vrG5tb+e2dugxjgUkNhywUTRdJwignNUUVI81IEBS4jDTc/nXiNx6IkDTk92oYESdAXU59ipHSUid/0PbCAUdChANTmsV2zD0ikmGQmyfHl3fmVSdfsErWBHCe2CkpgBTVTv5Lz8RxQLjCDEnZsq1IOSMkFMWMjHPtWJII4T7qkpamHAVEOqPJKWN4pBUP+qHQjys4UX93jFAg5TBwdWWAVE/Oeon4n9eKlX/hjCiPYkU4ni7yYwZVCJNcoEcFwYoNNUFYUP1XiHtIIKx0ejkdgj178jypl0v2aal8e1ao7KVxZME+OARFYINzUAE3oApqAINH8AxewZvxZLwY78bHtDRjpD274A+Mzx9EK5ku AAACEHicbVDLTgIxFO3gC/GFujFx00iMmCCZQRONK6IblxjlkQAhnXKBhk5nbDsSQvgEN/6KGxca49alO//GDsxC0ZM0OTnnPnqPG3CmtG1/WYm5+YXFpeRyamV1bX0jvblVUX4oKZSpz31Zc4kCzgSUNdMcaoEE4rkcqm7/MvKr9yAV88WtHgbQ9EhXsA6jRBuplT5otP2BIFL6g1xD3YVEQi7bCEUbZDQSi9zR4flN7qKVzth5ewL8lzgxyaAYpVb600ymoQdCU06Uqjt2oJsjIjWjHMapRqggILRPulA3VBAPVHM0OWiM943Sxh1fmic0nqg/O0bEU2rouabSI7qnZr1I/M+rh7pz1hwxEYQaBJ0u6oQcax9H6eA2k0A1HxpCqGTmr5j2iCRUmwxTJgRn9uS/pFLIO8f5wvVJprgTx5FEu2gPZZGDTlERXaESKiOKHtATekGv1qP1bL1Z79PShBX3bKNfsD6+ATxQm+Q=

⇤ AAACEXicbVDLSgMxFM34rPU16kZwEyxChVJmqqC4KrpxWdE+oDOUTHrbhmYyY5KxlNJfcOOvuHGhiFt37vwb08dCWw8EDufcR+4JYs6Udpxva2FxaXllNbWWXt/Y3Nq2d3YrKkokhTKNeCRrAVHAmYCyZppDLZZAwoBDNehejfzqA0jFInGn+zH4IWkL1mKUaCM17KzXjHqCSBn1cp66T4iEXNZLRBPkaCQWOcyOL25zlw074+SdMfA8cackg6YoNewvM5omIQhNOVGq7jqx9gdEakY5DNNeoiAmtEvaUDdUkBCUPxhfNMRHRmniViTNExqP1d8dAxIq1Q8DUxkS3VGz3kj8z6snunXuD5iIEw2CTha1Eo51hEfx4CaTQDXvG0KoZOavmHaIJFSbENMmBHf25HlSKeTdk3zh5jRT3J/GkUIH6BBlkYvOUBFdoxIqI4oe0TN6RW/Wk/VivVsfk9IFa9qzh/7A+vwB+4OcSg== ⇤ # # # # ⇤ # #

AAAB83icbVDLSsNAFJ3UV62vqks3g0VwVZIq6LLgxmUF+4AmlMnkph06mYR5CCX0N9y4UMStP+POv3HSZqGtBwYO59zDvXPCjDOlXffbqWxsbm3vVHdre/sHh0f145OeSo2k0KUpT+UgJAo4E9DVTHMYZBJIEnLoh9O7wu8/gVQsFY96lkGQkLFgMaNEW8n3jYhAFmGcjOoNt+kugNeJV5IGKtEZ1b/8KKUmAaEpJ0oNPTfTQU6kZpTDvOYbBRmhUzKGoaWCJKCCfHHzHF9YJcJxKu0TGi/U34mcJErNktBOJkRP1KpXiP95Q6Pj2yBnIjMaBF0uig3HOsVFAThiEqjmM0sIlczeiumESEK1ralmS/BWv7xOeq2md9VsPVw32riso4rO0Dm6RB66QW10jzqoiyjK0DN6RW+OcV6cd+djOVpxyswp+gPn8wfyQpGD m AAAB83icbVDLSsNAFJ3UV62vqks3g0VwVZIq6LLgxmUF+4AmlMnkph06mYR5CCX0N9y4UMStP+POv3HSZqGtBwYO59zDvXPCjDOlXffbqWxsbm3vVHdre/sHh0f145OeSo2k0KUpT+UgJAo4E9DVTHMYZBJIEnLoh9O7wu8/gVQsFY96lkGQkLFgMaNEW8n3jYhAFmGcjOoNt+kugNeJV5IGKtEZ1b/8KKUmAaEpJ0oNPTfTQU6kZpTDvOYbBRmhUzKGoaWCJKCCfHHzHF9YJcJxKu0TGi/U34mcJErNktBOJkRP1KpXiP95Q6Pj2yBnIjMaBF0uig3HOsVFAThiEqjmM0sIlczeiumESEK1ralmS/BWv7xOeq2md9VsPVw32riso4rO0Dm6RB66QW10jzqoiyjK0DN6RW+OcV6cd+djOVpxyswp+gPn8wfyQpGD m

AAAB6HicbVBNS8NAEJ3Ur1q/ql4EL4tF8FSSKuix4MVjC7YW2lA220m7drMJuxuhhP4CLx4U8epP8ua/cdvmoK0PBh7vzTAzL0gE18Z1v53C2vrG5lZxu7Szu7d/UD48aus4VQxbLBax6gRUo+ASW4YbgZ1EIY0CgQ/B+HbmPzyh0jyW92aSoB/RoeQhZ9RYqdnplytu1Z2DrBIvJxXI0eiXv3qDmKURSsME1brruYnxM6oMZwKnpV6qMaFsTIfYtVTSCLWfzQ+dknOrDEgYK1vSkLn6eyKjkdaTKLCdETUjvezNxP+8bmrCGz/jMkkNSrZYFKaCmJjMviYDrpAZMbGEMsXtrYSNqKLM2GxKNgRv+eVV0q5VvctqrXlVqZ/kcRThFM7gAjy4hjrcQQNawADhGV7hzXl0Xpx352PRWnDymWP4A+fzB6pljLY= X

AAAB6HicbVBNS8NAEJ3Ur1q/ql4EL4tF8FSSKuix4MVjC7YW2lA220m7drMJuxuhhP4CLx4U8epP8ua/cdvmoK0PBh7vzTAzL0gE18Z1v53C2vrG5lZxu7Szu7d/UD48aus4VQxbLBax6gRUo+ASW4YbgZ1EIY0CgQ/B+HbmPzyh0jyW92aSoB/RoeQhZ9RYqdnplytu1Z2DrBIvJxXI0eiXv3qDmKURSsME1brruYnxM6oMZwKnpV6qMaFsTIfYtVTSCLWfzQ+dknOrDEgYK1vSkLn6eyKjkdaTKLCdETUjvezNxP+8bmrCGz/jMkkNSrZYFKaCmJjMviYDrpAZMbGEMsXtrYSNqKLM2GxKNgRv+eVV0q5VvctqrXlVqZ/kcRThFM7gAjy4hjrcQQNawADhGV7hzXl0Xpx352PRWnDymWP4A+fzB6pljLY= AAAB6HicbVBNS8NAEJ34WetX1aOXxSJ4KkkV9FjoxWML9gPaUDbbSbt2swm7G6GE/gIvHhTx6k/y5r9x2+agrQ8GHu/NMDMvSATXxnW/nY3Nre2d3cJecf/g8Oi4dHLa1nGqGLZYLGLVDahGwSW2DDcCu4lCGgUCO8GkPvc7T6g0j+WDmSboR3QkecgZNVZq1gelsltxFyDrxMtJGXI0BqWv/jBmaYTSMEG17nluYvyMKsOZwFmxn2pMKJvQEfYslTRC7WeLQ2fk0ipDEsbKljRkof6eyGik9TQKbGdEzVivenPxP6+XmvDOz7hMUoOSLReFqSAmJvOvyZArZEZMLaFMcXsrYWOqKDM2m6INwVt9eZ20qxXvulJt3pRrJI+jAOdwAVfgwS3U4B4a0AIGCM/wCm/Oo/PivDsfy9YNJ585gz9wPn8AjPmMqQ== C X

r r' AAAB+XicbVDLSsNAFL2pr1pfUTeCm8EiuCpJFXRZcOOygn1AE8pkMmmHTiZhZlIooX/ixoUibv0Td/6NkzYLbT1w4XDOvTP3niDlTGnH+bYqG5tb2zvV3dre/sHhkX180lVJJgntkIQnsh9gRTkTtKOZ5rSfSorjgNNeMLkv/N6USsUS8aRnKfVjPBIsYgRrIw1t28u9TIRUFg8g4c2Hdt1pOAugdeKWpA4l2kP7ywsTksVUaMKxUgPXSbWfY6kZ4XRe8zJFU0wmeEQHhgocU+Xni83n6NIoIYoSaUpotFB/T+Q4VmoWB6YzxnqsVr1C/M8bZDq683Mm0kxTQZYfRRlHOkFFDChkkhLNZ4ZgIpnZFZExlphoE1bNhOCunrxOus2Ge91oPt7UW2dlHFU4hwu4AhduoQUP0IYOEJjCM7zCm5VbL9a79bFsrVjlzCn8gfX5A6H8k4U=

AAAB+XicbVDLSsNAFL2pr1pfUTeCm8EiuCpJFXRZcOOygn1AE8pkMmmHTiZhZlIooX/ixoUibv0Td/6NkzYLbT1w4XDOvTP3niDlTGnH+bYqG5tb2zvV3dre/sHhkX180lVJJgntkIQnsh9gRTkTtKOZ5rSfSorjgNNeMLkv/N6USsUS8aRnKfVjPBIsYgRrIw1t28u9TIRUFg8g4c2Hdt1pOAugdeKWpA4l2kP7ywsTksVUaMKxUgPXSbWfY6kZ4XRe8zJFU0wmeEQHhgocU+Xni83n6NIoIYoSaUpotFB/T+Q4VmoWB6YzxnqsVr1C/M8bZDq683Mm0kxTQZYfRRlHOkFFDChkkhLNZ4ZgIpnZFZExlphoE1bNhOCunrxOus2Ge91oPt7UW2dlHFU4hwu4AhduoQUP0IYOEJjCM7zCm5VbL9a79bFsrVjlzCn8gfX5A6H8k4U= { } { } AAAB83icbVDLSsNAFJ3UV62vqks3g0VwVZIq6LLgxmUF+4AmlMnkph06mYR5CCX0N9y4UMStP+POv3HSZqGtBwYO59zDvXPCjDOlXffbqWxsbm3vVHdre/sHh0f145OeSo2k0KUpT+UgJAo4E9DVTHMYZBJIEnLoh9O7wu8/gVQsFY96lkGQkLFgMaNEW8n3jYhAFmGcjOoNt+kugNeJV5IGKtEZ1b/8KKUmAaEpJ0oNPTfTQU6kZpTDvOYbBRmhUzKGoaWCJKCCfHHzHF9YJcJxKu0TGi/U34mcJErNktBOJkRP1KpXiP95Q6Pj2yBnIjMaBF0uig3HOsVFAThiEqjmM0sIlczeiumESEK1ralmS/BWv7xOeq2md9VsPVw32riso4rO0Dm6RB66QW10jzqoiyjK0DN6RW+OcV6cd+djOVpxyswp+gPn8wfyQpGD m

AAAB6HicbVBNS8NAEJ3Ur1q/ql4EL4tF8FSSKuix4MVjC7YW2lA220m7drMJuxuhhP4CLx4U8epP8ua/cdvmoK0PBh7vzTAzL0gE18Z1v53C2vrG5lZxu7Szu7d/UD48aus4VQxbLBax6gRUo+ASW4YbgZ1EIY0CgQ/B+HbmPzyh0jyW92aSoB/RoeQhZ9RYqcn75Ypbdecgq8TLSQVyNPrlr94gZmmE0jBBte56bmL8jCrDmcBpqZdqTCgb0yF2LZU0Qu1n80On5NwqAxLGypY0ZK7+nshopPUkCmxnRM1IL3sz8T+vm5rwxs+4TFKDki0WhakgJiazr8mAK2RGTCyhTHF7K2EjqigzNpuSDcFbfnmVtGtV77Jaa15V6id5HEU4hTO4AA+uoQ530IAWMEB4hld4cx6dF+fd+Vi0Fpx85hj+wPn8AcQpjMc= i AAAB6HicbVBNS8NAEJ3Ur1q/ql4EL4tF8FSSKuix4MVjC7YW2lA220m7drMJuxuhhP4CLx4U8epP8ua/cdvmoK0PBh7vzTAzL0gE18Z1v53C2vrG5lZxu7Szu7d/UD48aus4VQxbLBax6gRUo+ASW4YbgZ1EIY0CgQ/B+HbmPzyh0jyW92aSoB/RoeQhZ9RYqcn75Ypbdecgq8TLSQVyNPrlr94gZmmE0jBBte56bmL8jCrDmcBpqZdqTCgb0yF2LZU0Qu1n80On5NwqAxLGypY0ZK7+nshopPUkCmxnRM1IL3sz8T+vm5rwxs+4TFKDki0WhakgJiazr8mAK2RGTCyhTHF7K2EjqigzNpuSDcFbfnmVtGtV77Jaa15V6id5HEU4hTO4AA+uoQ530IAWMEB4hld4cx6dF+fd+Vi0Fpx85hj+wPn8AcQpjMc= i AAAB6HicbVBNS8NAEJ3Ur1q/ql4EL4tF8FSSKuix4MVjC7YW2lA220m7drMJuxuhhP4CLx4U8epP8ua/cdvmoK0PBh7vzTAzL0gE18Z1v53C2vrG5lZxu7Szu7d/UD48aus4VQxbLBax6gRUo+ASW4YbgZ1EIY0CgQ/B+HbmPzyh0jyW92aSoB/RoeQhZ9RYqcn75Ypbdecgq8TLSQVyNPrlr94gZmmE0jBBte56bmL8jCrDmcBpqZdqTCgb0yF2LZU0Qu1n80On5NwqAxLGypY0ZK7+nshopPUkCmxnRM1IL3sz8T+vm5rwxs+4TFKDki0WhakgJiazr8mAK2RGTCyhTHF7K2EjqigzNpuSDcFbfnmVtGtV77Jaa15V6id5HEU4hTO4AA+uoQ530IAWMEB4hld4cx6dF+fd+Vi0Fpx85hj+wPn8AcQpjMc= i n

AAAB+XicbVDLSsNAFL2pr1pfUTeCm8EiuCpJFXRZcOOygn1AE8pkMmmHTiZhZlIooX/ixoUibv0Td/6NkzYLbT1w4XDOvTP3niDlTGnH+bYqG5tb2zvV3dre/sHhkX180lVJJgntkIQnsh9gRTkTtKOZ5rSfSorjgNNeMLkv/N6USsUS8aRnKfVjPBIsYgRrIw1t28u9TIRUFg8g4c2Hdt1pOAugdeKWpA4l2kP7ywsTksVUaMKxUgPXSbWfY6kZ4XRe8zJFU0wmeEQHhgocU+Xni83n6NIoIYoSaUpotFB/T+Q4VmoWB6YzxnqsVr1C/M8bZDq683Mm0kxTQZYfRRlHOkFFDChkkhLNZ4ZgIpnZFZExlphoE1bNhOCunrxOus2Ge91oPt7UW2dlHFU4hwu4AhduoQUP0IYOEJjCM7zCm5VbL9a79bFsrVjlzCn8gfX5A6H8k4U= AAAB6HicbVBNS8NAEJ3Ur1q/qh69LBbBU0mqoMeCF48t2A9oQ9lsJ+3azSbsboQS+gu8eFDEqz/Jm//GbZuDtj4YeLw3w8y8IBFcG9f9dgobm1vbO8Xd0t7+weFR+fikreNUMWyxWMSqG1CNgktsGW4EdhOFNAoEdoLJ3dzvPKHSPJYPZpqgH9GR5CFn1FipqQblilt1FyDrxMtJBXI0BuWv/jBmaYTSMEG17nluYvyMKsOZwFmpn2pMKJvQEfYslTRC7WeLQ2fkwipDEsbKljRkof6eyGik9TQKbGdEzVivenPxP6+XmvDWz7hMUoOSLReFqSAmJvOvyZArZEZMLaFMcXsrYWOqKDM2m5INwVt9eZ20a1XvqlprXlfqJI+jCGdwDpfgwQ3U4R4a0AIGCM/wCm/Oo/PivDsfy9aCk8+cwh84nz/UNYzY r { }

,r(i), (n, ):S, B ,r(i), (n, ):S, B ,r(i), (n, ):S, B AAACBXicbVBNS8NAEN34WetX1Iugh2ARPJSSVEHxVPTisaL9gCaUyXbTLt1k4+5GKaEXL/4VLx4U8ep/8Oa/cdvmoK0PBh7vzTAzz48Zlcq2v425+YXFpeXcSn51bX1j09zarkueCExqmDMumj5IwmhEaooqRpqxIBD6jDT8/uXIb9wTISmPbtUgJl4I3YgGFIPSUtvcd5MYhOAPxdSVdwkIMiy6UoE4vyletM2CXbLHsGaJk5ECylBtm19uh+MkJJHCDKRsOXasvBSEopiRYd5NJIkB96FLWppGEBLppeMvhtahVjpWwIWuSFlj9fdECqGUg9DXnSGonpz2RuJ/XitRwZmX0ihOFInwZFGQMEtxaxSJ1aGCYMUGmgAWVN9q4R4IwEoHl9chONMvz5J6ueQcl8rXJ4XKbhZHDu2hA3SEHHSKKugKVVENYfSIntErejOejBfj3fiYtM4Z2cwO+gPj8wdheJhX , , ? : S, B AAACBXicbVBNS8NAEN34WetX1Iugh2ARPJSSVEHxVPTisaL9gCaUyXbTLt1k4+5GKaEXL/4VLx4U8ep/8Oa/cdvmoK0PBh7vzTAzz48Zlcq2v425+YXFpeXcSn51bX1j09zarkueCExqmDMumj5IwmhEaooqRpqxIBD6jDT8/uXIb9wTISmPbtUgJl4I3YgGFIPSUtvcd5MYhOAPxdSVdwkIMiy6UoE4vyletM2CXbLHsGaJk5ECylBtm19uh+MkJJHCDKRsOXasvBSEopiRYd5NJIkB96FLWppGEBLppeMvhtahVjpWwIWuSFlj9fdECqGUg9DXnSGonpz2RuJ/XitRwZmX0ihOFInwZFGQMEtxaxSJ1aGCYMUGmgAWVN9q4R4IwEoHl9chONMvz5J6ueQcl8rXJ4XKbhZHDu2hA3SEHHSKKugKVVENYfSIntErejOejBfj3fiYtM4Z2cwO+gPj8wdheJhX , , ? : S, B AAACBXicbVBNS8NAEN34WetX1Iugh2ARPJSSVEHxVPTisaL9gCaUyXbTLt1k4+5GKaEXL/4VLx4U8ep/8Oa/cdvmoK0PBh7vzTAzz48Zlcq2v425+YXFpeXcSn51bX1j09zarkueCExqmDMumj5IwmhEaooqRpqxIBD6jDT8/uXIb9wTISmPbtUgJl4I3YgGFIPSUtvcd5MYhOAPxdSVdwkIMiy6UoE4vyletM2CXbLHsGaJk5ECylBtm19uh+MkJJHCDKRsOXasvBSEopiRYd5NJIkB96FLWppGEBLppeMvhtahVjpWwIWuSFlj9fdECqGUg9DXnSGonpz2RuJ/XitRwZmX0ihOFInwZFGQMEtxaxSJ1aGCYMUGmgAWVN9q4R4IwEoHl9chONMvz5J6ueQcl8rXJ4XKbhZHDu2hA3SEHHSKKugKVVENYfSIntErejOejBfj3fiYtM4Z2cwO+gPj8wdheJhX , , ? : S, B

AAACD3icbVDLSgMxFM34rPU16kZwEyxKC7XMVEFxVXTjsqJ9QFtKJpO2oZlkSDKWMvQP3Pgrblwo4tatO//GtJ2Fth4IHM65j9zjhYwq7Tjf1sLi0vLKamotvb6xubVt7+xWlYgkJhUsmJB1DynCKCcVTTUj9VASFHiM1Lz+9divPRCpqOD3ehiSVoC6nHYoRtpIbfu46YsBR1KKQT6WWZob5bPNiPtEjidCnj/JXd7lr9p2xik4E8B54iYkAxKU2/aXGYyjgHCNGVKq4TqhbsVIaooZGaWbkSIhwn3UJQ1DOQqIasWTe0bwyCg+7AhpHtdwov7uiFGg1DDwTGWAdE/NemPxP68R6c5FK6Y8jDTheLqoEzGoBRyHA30qCdZsaAjCkpq/QtxDEmFtIkybENzZk+dJtVhwTwvF27NMaT+JIwUOwCHIAhecgxK4AWVQARg8gmfwCt6sJ+vFerc+pqULVtKzB/7A+vwBzj2bEQ== AAACD3icbVDLSgMxFM34rPU16kZwEyxKC7XMVEFxVXTjsqJ9QFtKJpO2oZlkSDKWMvQP3Pgrblwo4tatO//GtJ2Fth4IHM65j9zjhYwq7Tjf1sLi0vLKamotvb6xubVt7+xWlYgkJhUsmJB1DynCKCcVTTUj9VASFHiM1Lz+9divPRCpqOD3ehiSVoC6nHYoRtpIbfu46YsBR1KKQT6WWZob5bPNiPtEjidCnj/JXd7lr9p2xik4E8B54iYkAxKU2/aXGYyjgHCNGVKq4TqhbsVIaooZGaWbkSIhwn3UJQ1DOQqIasWTe0bwyCg+7AhpHtdwov7uiFGg1DDwTGWAdE/NemPxP68R6c5FK6Y8jDTheLqoEzGoBRyHA30qCdZsaAjCkpq/QtxDEmFtIkybENzZk+dJtVhwTwvF27NMaT+JIwUOwCHIAhecgxK4AWVQARg8gmfwCt6sJ+vFerc+pqULVtKzB/7A+vwBzj2bEQ== AAACD3icbVDLSgMxFM34rPU16kZwEyxKC7XMVEFxVXTjsqJ9QFtKJpO2oZlkSDKWMvQP3Pgrblwo4tatO//GtJ2Fth4IHM65j9zjhYwq7Tjf1sLi0vLKamotvb6xubVt7+xWlYgkJhUsmJB1DynCKCcVTTUj9VASFHiM1Lz+9divPRCpqOD3ehiSVoC6nHYoRtpIbfu46YsBR1KKQT6WWZob5bPNiPtEjidCnj/JXd7lr9p2xik4E8B54iYkAxKU2/aXGYyjgHCNGVKq4TqhbsVIaooZGaWbkSIhwn3UJQ1DOQqIasWTe0bwyCg+7AhpHtdwov7uiFGg1DDwTGWAdE/NemPxP68R6c5FK6Y8jDTheLqoEzGoBRyHA30qCdZsaAjCkpq/QtxDEmFtIkybENzZk+dJtVhwTwvF27NMaT+JIwUOwCHIAhecgxK4AWVQARg8gmfwCt6sJ+vFerc+pqULVtKzB/7A+vwBzj2bEQ== ⇤ # " ⇤ # " ⇤ # "

AAAB+XicbVDLSsNAFL2pr1pfUcGNm8EiuCpJFXRZcOOygn1AE8pkMmmHTiZhZlIooX/ixoUibv0Td/6NkzYLbT1w4XDOvTP3niDlTGnH+bYqG5tb2zvV3dre/sHhkX180lVJJgntkIQnsh9gRTkTtKOZ5rSfSorjgNNeMLkv/N6USsUS8aRnKfVjPBIsYgRrIw1t28u9TIRUFg+g2JsP7brTcBZA68QtSR1KtIf2lxcmJIup0IRjpQauk2o/x1Izwum85mWKpphM8IgODBU4psrPF5vP0aVRQhQl0pTQaKH+nshxrNQsDkxnjPVYrXqF+J83yHR05+dMpJmmgiw/ijKOdIKKGFDIJCWazwzBRDKzKyJjLDHRJqyaCcFdPXmddJsN97rRfLypt87KOKpwDhdwBS7cQgseoA0dIDCFZ3iFNyu3Xqx362PZWrHKmVP4A+vzB5/ck4I=

AAAB+XicbVDLSsNAFL2pr1pfUTeCm8EiuCpJFXRZcOOygn1AE8pkMmmHTiZhZlIooX/ixoUibv0Td/6NkzYLbT1w4XDOvTP3niDlTGnH+bYqG5tb2zvV3dre/sHhkX180lVJJgntkIQnsh9gRTkTtKOZ5rSfSorjgNNeMLkv/N6USsUS8aRnKfVjPBIsYgRrIw1t28u9TIRUFg8g4c2Hdt1pOAugdeKWpA4l2kP7ywsTksVUaMKxUgPXSbWfY6kZ4XRe8zJFU0wmeEQHhgocU+Xni83n6NIoIYoSaUpotFB/T+Q4VmoWB6YzxnqsVr1C/M8bZDq683Mm0kxTQZYfRRlHOkFFDChkkhLNZ4ZgIpnZFZExlphoE1bNhOCunrxOus2Ge91oPt7UW2dlHFU4hwu4AhduoQUP0IYOEJjCM7zCm5VbL9a79bFsrVjlzCn8gfX5A6H8k4U= AAAB+XicbVDLSsNAFL2pr1pfUTeCm8EiuCpJFXRZcOOygn1AE8pkMmmHTiZhZlIooX/ixoUibv0Td/6NkzYLbT1w4XDOvTP3niDlTGnH+bYqG5tb2zvV3dre/sHhkX180lVJJgntkIQnsh9gRTkTtKOZ5rSfSorjgNNeMLkv/N6USsUS8aRnKfVjPBIsYgRrIw1t28u9TIRUFg8g4c2Hdt1pOAugdeKWpA4l2kP7ywsTksVUaMKxUgPXSbWfY6kZ4XRe8zJFU0wmeEQHhgocU+Xni83n6NIoIYoSaUpotFB/T+Q4VmoWB6YzxnqsVr1C/M8bZDq683Mm0kxTQZYfRRlHOkFFDChkkhLNZ4ZgIpnZFZExlphoE1bNhOCunrxOus2Ge91oPt7UW2dlHFU4hwu4AhduoQUP0IYOEJjCM7zCm5VbL9a79bFsrVjlzCn8gfX5A6H8k4U= C C { } { } { }

i AAAB6HicbVBNS8NAEJ3Ur1q/ql4EL4tF8FSSKuix4MVjC7YW2lA220m7drMJuxuhhP4CLx4U8epP8ua/cdvmoK0PBh7vzTAzL0gE18Z1v53C2vrG5lZxu7Szu7d/UD48aus4VQxbLBax6gRUo+ASW4YbgZ1EIY0CgQ/B+HbmPzyh0jyW92aSoB/RoeQhZ9RYqcn75Ypbdecgq8TLSQVyNPrlr94gZmmE0jBBte56bmL8jCrDmcBpqZdqTCgb0yF2LZU0Qu1n80On5NwqAxLGypY0ZK7+nshopPUkCmxnRM1IL3sz8T+vm5rwxs+4TFKDki0WhakgJiazr8mAK2RGTCyhTHF7K2EjqigzNpuSDcFbfnmVtGtV77Jaa15V6id5HEU4hTO4AA+uoQ530IAWMEB4hld4cx6dF+fd+Vi0Fpx85hj+wPn8AcQpjMc= AAAB6HicbVBNS8NAEJ3Ur1q/ql4EL4tF8FSSKuix4MVjC7YW2lA220m7drMJuxuhhP4CLx4U8epP8ua/cdvmoK0PBh7vzTAzL0gE18Z1v53C2vrG5lZxu7Szu7d/UD48aus4VQxbLBax6gRUo+ASW4YbgZ1EIY0CgQ/B+HbmPzyh0jyW92aSoB/RoeQhZ9RYqcn75Ypbdecgq8TLSQVyNPrlr94gZmmE0jBBte56bmL8jCrDmcBpqZdqTCgb0yF2LZU0Qu1n80On5NwqAxLGypY0ZK7+nshopPUkCmxnRM1IL3sz8T+vm5rwxs+4TFKDki0WhakgJiazr8mAK2RGTCyhTHF7K2EjqigzNpuSDcFbfnmVtGtV77Jaa15V6id5HEU4hTO4AA+uoQ530IAWMEB4hld4cx6dF+fd+Vi0Fpx85hj+wPn8AcQpjMc= i i

() () AAAB83icbVDLSsNAFJ3UV62vqks3g0VwVZIq6LLgxmUF+4AmlMnkph06mYR5CCX0N9y4UMStP+POv3HSZqGtBwYO59zDvXPCjDOlXffbqWxsbm3vVHdre/sHh0f145OeSo2k0KUpT+UgJAo4E9DVTHMYZBJIEnLoh9O7wu8/gVQsFY96lkGQkLFgMaNEW8n3jYhAFmEsRvWG23QXwOvEK0kDleiM6l9+lFKTgNCUE6WGnpvpICdSM8phXvONgozQKRnD0FJBElBBvrh5ji+sEuE4lfYJjRfq70ROEqVmSWgnE6InatUrxP+8odHxbZAzkRkNgi4XxYZjneKiABwxCVTzmSWESmZvxXRCJKHa1lSzJXirX14nvVbTu2q2Hq4bbVzWUUVn6BxdIg/doDa6Rx3URRRl6Bm9ojfHOC/Ou/OxHK04ZeYU/YHz+QPzxpGE n AAAB6HicbVBNS8NAEJ3Ur1q/ql4EL4tF8FSSKuix4MVjC7YW2lA220m7drMJuxuhhP4CLx4U8epP8ua/cdvmoK0PBh7vzTAzL0gE18Z1v53C2vrG5lZxu7Szu7d/UD48aus4VQxbLBax6gRUo+ASW4YbgZ1EIY0CgQ/B+HbmPzyh0jyW92aSoB/RoeQhZ9RYqdnplytu1Z2DrBIvJxXI0eiXv3qDmKURSsME1brruYnxM6oMZwKnpV6qMaFsTIfYtVTSCLWfzQ+dknOrDEgYK1vSkLn6eyKjkdaTKLCdETUjvezNxP+8bmrCGz/jMkkNSrZYFKaCmJjMviYDrpAZMbGEMsXtrYSNqKLM2GxKNgRv+eVV0q5VvctqrXlVqZ/kcRThFM7gAjy4hjrcQQNawADhGV7hzXl0Xpx352PRWnDymWP4A+fzB6pljLY= X AAAB9XicbVDLSgMxFL1TX7W+qi7dBItQN2WmCrosuHFZwT6gHUsmvW1DM5khyShl6H+4caGIW//FnX9j2s5CWw8EDufcw705QSy4Nq777eTW1jc2t/LbhZ3dvf2D4uFRU0eJYthgkYhUO6AaBZfYMNwIbMcKaRgIbAXjm5nfekSleSTvzSRGP6RDyQecUWOlh24i+6hm4bR8Pu0VS27FnYOsEi8jJchQ7xW/uv2IJSFKwwTVuuO5sfFTqgxnAqeFbqIxpmxMh9ixVNIQtZ/Or56SM6v0ySBS9klD5urvREpDrSdhYCdDakZ62ZuJ/3mdxAyu/ZTLODEo2WLRIBHERGRWAelzhcyIiSWUKW5vJWxEFWXGFlWwJXjLX14lzWrFu6hU7y5LNZLVkYcTOIUyeHAFNbiFOjSAgYJneIU358l5cd6dj8Vozskyx/AHzucPY1SSUw== n AAAB9XicbVDLSgMxFL1TX7W+qi7dBItQN2WmCrosuHFZwT6gHUsmvW1DM5khyShl6H+4caGIW//FnX9j2s5CWw8EDufcw705QSy4Nq777eTW1jc2t/LbhZ3dvf2D4uFRU0eJYthgkYhUO6AaBZfYMNwIbMcKaRgIbAXjm5nfekSleSTvzSRGP6RDyQecUWOlh24i+6hm4bR8Pu0VS27FnYOsEi8jJchQ7xW/uv2IJSFKwwTVuuO5sfFTqgxnAqeFbqIxpmxMh9ixVNIQtZ/Or56SM6v0ySBS9klD5urvREpDrSdhYCdDakZ62ZuJ/3mdxAyu/ZTLODEo2WLRIBHERGRWAelzhcyIiSWUKW5vJWxEFWXGFlWwJXjLX14lzWrFu6hU7y5LNZLVkYcTOIUyeHAFNbiFOjSAgYJneIU358l5cd6dj8Vozskyx/AHzucPY1SSUw== {AAAB+XicbVDLSsNAFL2pr1pfUTeCm8EiuCpJFXRZcOOygn1AE8pkMmmHTiZhZlIooX/ixoUibv0Td/6NkzYLbT1w4XDOvTP3niDlTGnH+bYqG5tb2zvV3dre/sHhkX180lVJJgntkIQnsh9gRTkTtKOZ5rSfSorjgNNeMLkv/N6USsUS8aRnKfVjPBIsYgRrIw1t28u9TIRUFg8g4c2Hdt1pOAugdeKWpA4l2kP7ywsTksVUaMKxUgPXSbWfY6kZ4XRe8zJFU0wmeEQHhgocU+Xni83n6NIoIYoSaUpotFB/T+Q4VmoWB6YzxnqsVr1C/M8bZDq683Mm0kxTQZYfRRlHOkFFDChkkhLNZ4ZgIpnZFZExlphoE1bNhOCunrxOus2Ge91oPt7UW2dlHFU4hwu4AhduoQUP0IYOEJjCM7zCm5VbL9a79bFsrVjlzCn8gfX5A6H8k4U= }

a l AAAB6HicbVBNS8NAEJ3Ur1q/ql4EL4tF8FSSKuix4MVjC7YW2lA220m7drMJuxuhhP4CLx4U8epP8ua/cdvmoK0PBh7vzTAzL0gE18Z1v53C2vrG5lZxu7Szu7d/UD48aus4VQxbLBax6gRUo+ASW4YbgZ1EIY0CgQ/B+HbmPzyh0jyW92aSoB/RoeQhZ9RYqcn75Ypbdecgq8TLSQVyNPrlr94gZmmE0jBBte56bmL8jCrDmcBpqZdqTCgb0yF2LZU0Qu1n80On5NwqAxLGypY0ZK7+nshopPUkCmxnRM1IL3sz8T+vm5rwxs+4TFKDki0WhakgJiazr8mAK2RGTCyhTHF7K2EjqigzNpuSDcFbfnmVtGtV77Jaa15V6id5HEU4hTO4AA+uoQ530IAWMEB4hld4cx6dF+fd+Vi0Fpx85hj+wPn8AcQpjMc= i op

AAAB6HicbVBNS8NAEJ3Ur1q/qh69LBbBU0mqoMeCF48t2A9oQ9lsJ+3azSbsboQS+gu8eFDEqz/Jm//GbZuDtj4YeLw3w8y8IBFcG9f9dgobm1vbO8Xd0t7+weFR+fikreNUMWyxWMSqG1CNgktsGW4EdhOFNAoEdoLJ3dzvPKHSPJYPZpqgH9GR5CFn1FipSQflilt1FyDrxMtJBXI0BuWv/jBmaYTSMEG17nluYvyMKsOZwFmpn2pMKJvQEfYslTRC7WeLQ2fkwipDEsbKljRkof6eyGik9TQKbGdEzVivenPxP6+XmvDWz7hMUoOSLReFqSAmJvOvyZArZEZMLaFMcXsrYWOqKDM2m5INwVt9eZ20a1XvqlprXlfqJI+jCGdwDpfgwQ3U4R4a0AIGCM/wCm/Oo/PivDsfy9aCk8+cwh84nz+6cYzH

AAAB6HicbVBNS8NAEJ3Ur1q/qh69LBbBU0mqoMeCF48t2A9oQ9lsJ+3azSbsboQS+gu8eFDEqz/Jm//GbZuDtj4YeLw3w8y8IBFcG9f9dgobm1vbO8Xd0t7+weFR+fikreNUMWyxWMSqG1CNgktsGW4EdhOFNAoEdoLJ3dzvPKHSPJYPZpqgH9GR5CFn1FipKQblilt1FyDrxMtJBXI0BuWv/jBmaYTSMEG17nluYvyMKsOZwFmpn2pMKJvQEfYslTRC7WeLQ2fkwipDEsbKljRkof6eyGik9TQKbGdEzVivenPxP6+XmvDWz7hMUoOSLReFqSAmJvOvyZArZEZMLaFMcXsrYWOqKDM2m5INwVt9eZ20a1XvqlprXlfqJI+jCGdwDpfgwQ3U4R4a0AIGCM/wCm/Oo/PivDsfy9aCk8+cwh84nz/LHYzS

AAAB6HicbVBNS8NAEJ34WetX1aOXxSJ4KkkV9FjoxWML9gPaUDbbSbt2swm7G6GE/gIvHhTx6k/y5r9x2+agrQ8GHu/NMDMvSATXxnW/nY3Nre2d3cJecf/g8Oi4dHLa1nGqGLZYLGLVDahGwSW2DDcCu4lCGgUCO8GkPvc7T6g0j+WDmSboR3QkecgZNVZq1gelsltxFyDrxMtJGXI0BqWv/jBmaYTSMEG17nluYvyMKsOZwFmxn2pMKJvQEfYslTRC7WeLQ2fk0ipDEsbKljRkof6eyGik9TQKbGdEzVivenPxP6+XmvDOz7hMUoOSLReFqSAmJvOvyZArZEZMLaFMcXsrYWOqKDM2m6INwVt9eZ20qxXvulJt3pRrJI+jAOdwAVfgwS3U4B4a0AIGCM/wCm/Oo/PivDsfy9YNJ585gz9wPn8AjPmMqQ== AAAB6HicbVBNS8NAEJ3Ur1q/qh69rBbBU0mqoMeCF48t2FpoQ9lsJ+3azSbsboQS+gu8eFDEqz/Jm//GbZuDtj4YeLw3w8y8IBFcG9f9dgpr6xubW8Xt0s7u3v5B+fCoreNUMWyxWMSqE1CNgktsGW4EdhKFNAoEPgTj25n/8IRK81jem0mCfkSHkoecUWOl5mm/XHGr7hxklXg5qUCORr/81RvELI1QGiao1l3PTYyfUWU4Ezgt9VKNCWVjOsSupZJGqP1sfuiUnFtlQMJY2ZKGzNXfExmNtJ5Ege2MqBnpZW8m/ud1UxPe+BmXSWpQssWiMBXExGT2NRlwhcyIiSWUKW5vJWxEFWXGZlOyIXjLL6+Sdq3qXVZrzatKneRxFOEEzuACPLiGOtxBA1rAAOEZXuHNeXRenHfnY9FacPKZY/gD5/MHWXGMhw== AAAB6HicbVBNS8NAEJ34WetX1aOXxSJ4KkkV9FjoxWML9gPaUDbbSbt2swm7G6GE/gIvHhTx6k/y5r9x2+agrQ8GHu/NMDMvSATXxnW/nY3Nre2d3cJecf/g8Oi4dHLa1nGqGLZYLGLVDahGwSW2DDcCu4lCGgUCO8GkPvc7T6g0j+WDmSboR3QkecgZNVZq1gelsltxFyDrxMtJGXI0BqWv/jBmaYTSMEG17nluYvyMKsOZwFmxn2pMKJvQEfYslTRC7WeLQ2fk0ipDEsbKljRkof6eyGik9TQKbGdEzVivenPxP6+XmvDOz7hMUoOSLReFqSAmJvOvyZArZEZMLaFMcXsrYWOqKDM2m6INwVt9eZ20qxXvulJt3pRrJI+jAOdwAVfgwS3U4B4a0AIGCM/wCm/Oo/PivDsfy9YNJ585gz9wPn8AjPmMqQ== AAAB6HicbVBNS8NAEJ3Ur1q/qh69rBbBU0mqoMeCF48t2FpoQ9lsJ+3azSbsboQS+gu8eFDEqz/Jm//GbZuDtj4YeLw3w8y8IBFcG9f9dgpr6xubW8Xt0s7u3v5B+fCoreNUMWyxWMSqE1CNgktsGW4EdhKFNAoEPgTj25n/8IRK81jem0mCfkSHkoecUWOl5mm/XHGr7hxklXg5qUCORr/81RvELI1QGiao1l3PTYyfUWU4Ezgt9VKNCWVjOsSupZJGqP1sfuiUnFtlQMJY2ZKGzNXfExmNtJ5Ege2MqBnpZW8m/ud1UxPe+BmXSWpQssWiMBXExGT2NRlwhcyIiSWUKW5vJWxEFWXGZlOyIXjLL6+Sdq3qXVZrzatKneRxFOEEzuACPLiGOtxBA1rAAOEZXuHNeXRenHfnY9FacPKZY/gD5/MHWXGMhw== a C ! C l ! AAAB6XicbVBNS8NAEJ3Ur1q/qh69LFbBU0mqoMeCF49V7Ae0oWy2k3bpZhN2N0IJ/QdePCji1X/kzX/jts1BWx8MPN6bYWZekAiujet+O4W19Y3NreJ2aWd3b/+gfHjU0nGqGDZZLGLVCahGwSU2DTcCO4lCGgUC28H4dua3n1BpHstHM0nQj+hQ8pAzaqz00Dvrlytu1Z2DrBIvJxXI0eiXv3qDmKURSsME1brruYnxM6oMZwKnpV6qMaFsTIfYtVTSCLWfzS+dknOrDEgYK1vSkLn6eyKjkdaTKLCdETUjvezNxP+8bmrCGz/jMkkNSrZYFKaCmJjM3iYDrpAZMbGEMsXtrYSNqKLM2HBKNgRv+eVV0qpVvctq7f6qUid5HEU4gVO4AA+uoQ530IAmMAjhGV7hzRk7L86787FoLTj5zDH8gfP5Aw68jPA= $ C ! C

,a(m,i), ((), ):S, B , , ((), ):S, B ,l(i), ((), ):S, B , , ((), ):S, B , $, (n, ):S, B , , (n, ):S, B

AAACDXicbVDLSgMxFM3UV62vUTeCm2ArVBjLTBUUV0U3LivaB7SlZDJpG5rJDEnGUob+gBt/xY0LRdy6d+ffmGlnodUDgcM595F73JBRqWz7y8gsLC4tr2RXc2vrG5tb5vZOXQaRwKSGAxaIposkYZSTmqKKkWYoCPJdRhru8CrxG/dESBrwOzUOScdHfU57FCOlpa5ZaHvBiCMhgpEVtwsTq9iOuEdEMg9y6/jo4ta67Jp5u2RPAf8SJyV5kKLaNT/1WBz5hCvMkJQtxw5VJ0ZCUczIJNeOJAkRHqI+aWnKkU9kJ55eM4GHWvFgLxD6cQWn6s+OGPlSjn1XV/pIDeS8l4j/ea1I9c47MeVhpAjHs0W9iEEVwCQa6FFBsGJjTRAWVP8V4gESCCsdYE6H4Myf/JfUyyXnpFS+Oc1X9tI4smAfHIAicMAZqIBrUAU1gMEDeAIv4NV4NJ6NN+N9Vpox0p5d8AvGxzdko5pR AAACEnicbVDLSgMxFM3UV62vUTeCm2ARWqhlpgqKq6IblxXtA9pSMultDc1kxiRjKUO/wY2/4saFIm5dufNvTB8LbT0QOJxzH7nHCzlT2nG+rcTC4tLySnI1tba+sbllb+9UVBBJCmUa8EDWPKKAMwFlzTSHWiiB+B6Hqte7HPnVB5CKBeJWD0Jo+qQrWIdRoo3UsrONdtAXRMqgn4sb6j4iEoa5TCMSbZCjoVjkjrLnN7mLlp128s4YeJ64U5JGU5Ra9peZTSMfhKacKFV3nVA3YyI1oxyGqUakICS0R7pQN1QQH1QzHp80xIdGaeNOIM0TGo/V3x0x8ZUa+J6p9Im+U7PeSPzPq0e6c9aMmQgjDYJOFnUijnWAR/ngNpNANR8YQqhk5q+Y3hFJqDYppkwI7uzJ86RSyLvH+cL1Sbq4N40jifbRAcogF52iIrpCJVRGFD2iZ/SK3qwn68V6tz4mpQlr2rOL/sD6/AEi4Zzw

AAACHnicbVDLSgMxFM3UV62vUTeCm2ARWhjLTFUUV0U3LivaB7RDyWTSNjSTGZKMpQz9Ejf+ihsXigiu9G9MH4vaeiBwOOc+co8XMSqVbf8YqaXlldW19HpmY3Nre8fc3avKMBaYVHDIQlH3kCSMclJRVDFSjwRBgcdIzevdjPzaIxGShvxBDSLiBqjDaZtipLTUMs+bftjnSIiwbyUo14y5T8RoWBIMLZofWjMSzOWtk/zVvXXdMrN2wR4DLhJnSrJginLL/NJ7cBwQrjBDUjYcO1JugoSimJFhphlLEiHcQx3S0JSjgEg3GZ83hMda8WE7FPpxBcfqbEeCAikHgacrA6S6ct4bif95jVi1L92E8ihWhOPJonbMoArhKCvoU0GwYgNNEBZU/xXiLhIIK51oRofgzJ+8SKrFgnNaKN6dZUsH0zjS4BAcgRxwwAUogVtQBhWAwRN4AW/g3Xg2Xo0P43NSmjKmPfvgD4zvX2YCoSw= AAACE3icbVDLTgIxFO3gC/GFujFx00hMwCCZQRONK6IblxjlkQAhnXKBhk5nbDsSMuEf3PgrblxojFs37vwby2Oh4EmanJxzH73HDThT2ra/rdjC4tLySnw1sba+sbmV3N4pKz+UFErU576sukQBZwJKmmkO1UAC8VwOFbd3NfIrDyAV88WdHgTQ8EhHsDajRBupmTyqt/y+IFL6/WxUV/chkTDMpuuhaIEcDcXpTPY4c3GbvWwmU3bOHgPPE2dKUmiKYjP5ZYbT0AOhKSdK1Rw70I2ISM0oh2GiHioICO2RDtQMFcQD1YjGNw3xoVFauO1L84TGY/V3R0Q8pQaeayo9ortq1huJ/3m1ULfPGxETQahB0Mmidsix9vEoINxiEqjmA0MIlcz8FdMukYRqE2PChODMnjxPyvmcc5LL35ymCnvTOOJoHx2gNHLQGSqga1REJUTRI3pGr+jNerJerHfrY1Ias6Y9u+gPrM8fKIOc3Q== AAACEHicbVDLSgMxFM34rPU16kZwEyziFGqZqYLiqujGZUX7gHYomTRtQzPJkGQsZegnuPFX3LhQxK1Ld/6N6WOhrQcCh3PuI/cEEaNKu+63tbC4tLyymlpLr29sbm3bO7sVJWKJSRkLJmQtQIowyklZU81ILZIEhQEj1aB3PfKrD0QqKvi9HkTED1GH0zbFSBupaR83WqLPkZSin0uYQ7PDnNOIeYvI0UToZHMn2cu73FXTzrh5dww4T7wpyYApSk37y0zGcUi4xgwpVffcSPsJkppiRobpRqxIhHAPdUjdUI5CovxkfNAQHhmlBdtCmsc1HKu/OxIUKjUIA1MZIt1Vs95I/M+rx7p94SeUR7EmHE8WtWMGtYCjdGCLSoI1GxiCsKTmrxB3kURYmwzTJgRv9uR5UinkvdN84fYsU9yfxpECB+AQOMAD56AIbkAJlAEGj+AZvII368l6sd6tj0npgjXt2QN/YH3+AMhkmvg= AAACE3icbVDLTgIxFO3gC/GFujFx00hMwCCZQRONK6IblxjlkQAhnXKBhk5nbDsSMuEf3PgrblxojFs37vwby2Oh4EmanJxzH73HDThT2ra/rdjC4tLySnw1sba+sbmV3N4pKz+UFErU576sukQBZwJKmmkO1UAC8VwOFbd3NfIrDyAV88WdHgTQ8EhHsDajRBupmTyqt/y+IFL6/WxUV/chkTDMpuuhaIEcDcXpTPY4c3GbvWwmU3bOHgPPE2dKUmiKYjP5ZYbT0AOhKSdK1Rw70I2ISM0oh2GiHioICO2RDtQMFcQD1YjGNw3xoVFauO1L84TGY/V3R0Q8pQaeayo9ortq1huJ/3m1ULfPGxETQahB0Mmidsix9vEoINxiEqjmA0MIlcz8FdMukYRqE2PChODMnjxPyvmcc5LL35ymCnvTOOJoHx2gNHLQGSqga1REJUTRI3pGr+jNerJerHfrY1Ias6Y9u+gPrM8fKIOc3Q== ⇤ # # ⇤ # # ⇤ # #

Figure 10 Computation rewrites

it involves no copying of the argument. To anticipate a little, the copying will be performed by the contraction nodes. The s-rule: represents the ‘step’ command which evaluates the dataflow graph, which will be discussed later. This rewrite, with an token exiting the incoming port d = is performed after this evaluation. The dataflow evaluation leaves a value n on S↓ indicating that n nodes were updated, so the s-node is replaced by a constant n value box. The p-rule: represents the ‘peek’ command which reads the value off the dataflow graph, as pointed at by the p node, and creates an constant n valued box from it. Note that the outgoing port of the p node is replaced by a weakening C, indicating that port became unreachable. The m-rule: represents cell creation, and is executed by replacing the m node by a n- initialised cell node. The value n is retrieved off the stack n, where it is augmented

12:15 Transparent Synchronous Dataflow

l AAAB6nicbVDLSgNBEOz1GeMr6tHLYBA8hd0o6DHgxWNE84BkCbOT2WTIzOwy0yuEkE/w4kERr36RN//GSbIHTSxoKKq66e6KUiks+v63t7a+sbm1Xdgp7u7tHxyWjo6bNskM4w2WyMS0I2q5FJo3UKDk7dRwqiLJW9Hodua3nrixItGPOE55qOhAi1gwik566KqsVyr7FX8OskqCnJQhR71X+ur2E5YprpFJam0n8FMMJ9SgYJJPi93M8pSyER3wjqOaKm7DyfzUKTl3Sp/EiXGlkczV3xMTqqwdq8h1KopDu+zNxP+8TobxTTgROs2Qa7ZYFGeSYEJmf5O+MJyhHDtCmRHuVsKG1FCGLp2iCyFYfnmVNKuV4LJSvb8q10geRwFO4QwuIIBrqMEd1KEBDAbwDK/w5knvxXv3Phata14+cwJ/4H3+AFRyjbg= µ l l Cc AAAB6HicbVBNS8NAEJ34WetX1aOXxSJ4KkkV9FjoxWML9gPaUDbbSbt2swm7G6GE/gIvHhTx6k/y5r9x2+agrQ8GHu/NMDMvSATXxnW/nY3Nre2d3cJecf/g8Oi4dHLa1nGqGLZYLGLVDahGwSW2DDcCu4lCGgUCO8GkPvc7T6g0j+WDmSboR3QkecgZNVZq1gelsltxFyDrxMtJGXI0BqWv/jBmaYTSMEG17nluYvyMKsOZwFmxn2pMKJvQEfYslTRC7WeLQ2fk0ipDEsbKljRkof6eyGik9TQKbGdEzVivenPxP6+XmvDOz7hMUoOSLReFqSAmJvOvyZArZEZMLaFMcXsrYWOqKDM2m6INwVt9eZ20qxXvulJt3pRrJI+jAOdwAVfgwS3U4B4a0AIGCM/wCm/Oo/PivDsfy9YNJ585gz9wPn8AjPmMqQ== C C

X X AAAB6HicbVBNS8NAEJ3Ur1q/qh69rBbBU0mqoMeCF48t2FpoQ9lsJ+3azSbsboQS+gu8eFDEqz/Jm//GbZuDtj4YeLw3w8y8IBFcG9f9dgpr6xubW8Xt0s7u3v5B+fCoreNUMWyxWMSqE1CNgktsGW4EdhKFNAoEPgTj25n/8IRK81jem0mCfkSHkoecUWOl5mm/XHGr7hxklXg5qUCORr/81RvELI1QGiao1l3PTYyfUWU4Ezgt9VKNCWVjOsSupZJGqP1sfuiUnFtlQMJY2ZKGzNXfExmNtJ5Ege2MqBnpZW8m/ud1UxPe+BmXSWpQssWiMBXExGT2NRlwhcyIiSWUKW5vJWxEFWXGZlOyIXjLL6+Sdq3qXVZrzatKneRxFOEEzuACPLiGOtxBA1rAAOEZXuHNeXRenHfnY9FacPKZY/gD5/MHWXGMhw== ! m m

AAAB+XicbVDLSsNAFJ3UV62vqBvBzWARXJSSVEGXRTcuK9pWaEKZTCft0JlJmEelhP6JGxeKuPVP3Pk3TtsstPXAhcM593LvPVHKqNKe9+0UVlbX1jeKm6Wt7Z3dPXf/oKUSIzFp4oQl8jFCijAqSFNTzchjKgniESPtaHgz9dsjIhVNxIMepyTkqC9oTDHSVuq6bmBSJGXyVAm4qdxXrrtu2at6M8Bl4uekDHI0uu5X0Euw4URozJBSHd9LdZghqSlmZFIKjCIpwkPUJx1LBeJEhdns8gk8tUoPxom0JTScqb8nMsSVGvPIdnKkB2rRm4r/eR2j46swoyI1mgg8XxQbBnUCpzHAHpUEaza2BGFJ7a0QD5BEWNuwSjYEf/HlZdKqVf3zau3uolw/yuMogmNwAs6ADy5BHdyCBmgCDEbgGbyCNydzXpx352PeWnDymUPwB87nD7Lekug= AAAB/XicbVDLSgMxFM3UV62v8bEQ3ASL4KKUmSooXRW7cVnRPqAdSibNtKGZZEgySh2Kv+LGhSJu/Q93/o1pOwttPXDhcM693HuPHzGqtON8W5ml5ZXVtex6bmNza3vH3t1rKBFLTOpYMCFbPlKEUU7qmmpGWpEkKPQZafrD6sRv3hOpqOB3ehQRL0R9TgOKkTZS1z7oxBGSUjwUkuq4cFtg5bB81bXzTtGZAi4SNyV5kKLWtb86PYHjkHCNGVKq7TqR9hIkNcWMjHOdWJEI4SHqk7ahHIVEecn0+jE8MUoPBkKa4hpO1d8TCQqVGoW+6QyRHqh5byL+57VjHVx6CeVRrAnHs0VBzKAWcBIF7FFJsGYjQxCW1NwK8QBJhLUJLGdCcOdfXiSNUtE9K5ZuzvOVwzSOLDgCx+AUuOACVMA1qIE6wOARPINX8GY9WS/Wu/Uxa81Y6cw++APr8wdVNZRa ,C,S,l : m : B AAAB+3icbVDLSgMxFM3UV62vsW4EN8EiuChlpgqKq2I3LivaB7RDyaSZNjTJDElGLcP8ihsXirj1R9z5N6btLLT1wIXDOfdy7z1+xKjSjvNt5VZW19Y38puFre2d3T17v9hSYSwxaeKQhbLjI0UYFaSpqWakE0mCuM9I2x/Xp377gUhFQ3GvJxHxOBoKGlCMtJH6drEXR0jK8LGc1NPyXZlfXfftklNxZoDLxM1ICWRo9O2v3iDEMSdCY4aU6rpOpL0ESU0xI2mhFysSITxGQ9I1VCBOlJfMbk/hiVEGMAilKaHhTP09kSCu1IT7ppMjPVKL3lT8z+vGOrj0EiqiWBOB54uCmEEdwmkQcEAlwZpNDEFYUnMrxCMkEdYmroIJwV18eZm0qhX3rFK9PS/VDrM48uAIHINT4IILUAM3oAGaAIMn8AxewZuVWi/Wu/Uxb81Z2cwB+APr8wcB6JOg ,C,S,m: B AAAB+XicbVBNS8NAEJ3Ur1q/ol4EL4tF8FBKUgU9FnvxWNF+QBvKZrtpl242YXdTKaH/xIsHRbz6T7z5b9y2OWjrg4HHezPMzPNjzpR2nG8rt7a+sbmV3y7s7O7tH9iHR00VJZLQBol4JNs+VpQzQRuaaU7bsaQ49Dlt+aPazG+NqVQsEo96ElMvxAPBAkawNlLPtrtJjKWMnkppbVp6KN327KJTduZAq8TNSBEy1Hv2V7cfkSSkQhOOleq4Tqy9FEvNCKfTQjdRNMZkhAe0Y6jAIVVeOr98is6N0kdBJE0Jjebq74kUh0pNQt90hlgP1bI3E//zOokObryUiTjRVJDFoiDhSEdoFgPqM0mJ5hNDMJHM3IrIEEtMtAmrYEJwl19eJc1K2b0sV+6vitWTLI48nMIZXIAL11CFO6hDAwiM4Rle4c1KrRfr3fpYtOasbOYY/sD6/AGuWpLl ,C,S,B AAAB/3icbVDLSgMxFM3UV62vUUEEN8EiuChlpgq6LLpxWdE+oDOUTJppQzPJmGSUMnbhr7hxoYhbf8Odf2PazkJbD1w4nHMv994TxIwq7TjfVm5hcWl5Jb9aWFvf2Nyyt3caSiQSkzoWTMhWgBRhlJO6ppqRViwJigJGmsHgcuw374lUVPBbPYyJH6EepyHFSBupY+95SYykFA+l1FN3CZJkVLopXXTsolN2JoDzxM1IEWSodewvrytwEhGuMUNKtV0n1n6KpKaYkVHBSxSJER6gHmkbylFElJ9O7h/BI6N0YSikKa7hRP09kaJIqWEUmM4I6b6a9cbif1470eG5n1IeJ5pwPF0UJgxqAcdhwC6VBGs2NARhSc2tEPeRRFibyAomBHf25XnSqJTdk3Ll+rRY3c/iyIMDcAiOgQvOQBVcgRqoAwwewTN4BW/Wk/VivVsf09aclc3sgj+wPn8AxbOVyw== , ,S,B ,µ,S,B ⇤ AAAB/3icbVDLSgMxFM3UV62vUUEEN8EiuChlpgq6LLpxWdE+oDOUTJppQzPJmGSUMnbhr7hxoYhbf8Odf2PazkJbD1w4nHMv994TxIwq7TjfVm5hcWl5Jb9aWFvf2Nyyt3caSiQSkzoWTMhWgBRhlJO6ppqRViwJigJGmsHgcuw374lUVPBbPYyJH6EepyHFSBupY+95SYykFA+l1FN3CZJkVLopXXTsolN2JoDzxM1IEWSodewvrytwEhGuMUNKtV0n1n6KpKaYkVHBSxSJER6gHmkbylFElJ9O7h/BI6N0YSikKa7hRP09kaJIqWEUmM4I6b6a9cbif1470eG5n1IeJ5pwPF0UJgxqAcdhwC6VBGs2NARhSc2tEPeRRFibyAomBHf25XnSqJTdk3Ll+rRY3c/iyIMDcAiOgQvOQBVcgRqoAwwewTN4BW/Wk/VivVsf09aclc3sgj+wPn8AxbOVyw== , ,S,B " " " " " " ⇤

AAAB6HicbVDLSgNBEOyNrxhfUS+Cl8EgeAq7UdBjwIMeEzAPSJYwO+lNxszOLjOzQgj5Ai8eFPHqJ3nzb5wke9DEgoaiqpvuriARXBvX/XZya+sbm1v57cLO7t7+QfHwqKnjVDFssFjEqh1QjYJLbBhuBLYThTQKBLaC0e3Mbz2h0jyWD2acoB/RgeQhZ9RYqX7XK5bcsjsHWSVeRkqQodYrfnX7MUsjlIYJqnXHcxPjT6gynAmcFrqpxoSyER1gx1JJI9T+ZH7olJxbpU/CWNmShszV3xMTGmk9jgLbGVEz1MveTPzP66QmvPEnXCapQckWi8JUEBOT2dekzxUyI8aWUKa4vZWwIVWUGZtNwYbgLb+8SpqVsndZrtSvStWTLI48nMIZXIAH11CFe6hBAxggPMMrvDmPzovz7nwsWnNONnMMf+B8/gCQoYyl AAAB6HicbVDLSgNBEOyNrxhfUS+Cl8EgeAq7UdBjwIMeEzAPSJYwO+lNxszOLjOzQgj5Ai8eFPHqJ3nzb5wke9DEgoaiqpvuriARXBvX/XZya+sbm1v57cLO7t7+QfHwqKnjVDFssFjEqh1QjYJLbBhuBLYThTQKBLaC0e3Mbz2h0jyWD2acoB/RgeQhZ9RYqX7XK5bcsjsHWSVeRkqQodYrfnX7MUsjlIYJqnXHcxPjT6gynAmcFrqpxoSyER1gx1JJI9T+ZH7olJxbpU/CWNmShszV3xMTGmk9jgLbGVEz1MveTPzP66QmvPEnXCapQckWi8JUEBOT2dekzxUyI8aWUKa4vZWwIVWUGZtNwYbgLb+8SpqVsndZrtSvStWTLI48nMIZXIAH11CFe6hBAxggPMMrvDmPzovz7nwsWnNONnMMf+B8/gCQoYyl G G G G !

AAAB6HicbVDLSgNBEOyNrxhfUS+Cl8EgeAq7UdBjwIMeEzAPSJYwO+lNxszOLjOzQgj5Ai8eFPHqJ3nzb5wke9DEgoaiqpvuriARXBvX/XZya+sbm1v57cLO7t7+QfHwqKnjVDFssFjEqh1QjYJLbBhuBLYThTQKBLaC0e3Mbz2h0jyWD2acoB/RgeQhZ9RYqX7XK5bcsjsHWSVeRkqQodYrfnX7MUsjlIYJqnXHcxPjT6gynAmcFrqpxoSyER1gx1JJI9T+ZH7olJxbpU/CWNmShszV3xMTGmk9jgLbGVEz1MveTPzP66QmvPEnXCapQckWi8JUEBOT2dekzxUyI8aWUKa4vZWwIVWUGZtNwYbgLb+8SpqVsndZrtSvStWTLI48nMIZXIAH11CFe6hBAxggPMMrvDmPzovz7nwsWnNONnMMf+B8/gCQoYyl G AAAB6HicbVDLSgNBEOyNrxhfUS+Cl8EgeAq7UdBjwIMeEzAPSJYwO+lNxszOLjOzQgj5Ai8eFPHqJ3nzb5wke9DEgoaiqpvuriARXBvX/XZya+sbm1v57cLO7t7+QfHwqKnjVDFssFjEqh1QjYJLbBhuBLYThTQKBLaC0e3Mbz2h0jyWD2acoB/RgeQhZ9RYqX7XK5bcsjsHWSVeRkqQodYrfnX7MUsjlIYJqnXHcxPjT6gynAmcFrqpxoSyER1gx1JJI9T+ZH7olJxbpU/CWNmShszV3xMTGmk9jgLbGVEz1MveTPzP66QmvPEnXCapQckWi8JUEBOT2dekzxUyI8aWUKa4vZWwIVWUGZtNwYbgLb+8SpqVsndZrtSvStWTLI48nMIZXIAH11CFe6hBAxggPMMrvDmPzovz7nwsWnNONnMMf+B8/gCQoYyl G

C-! AAAB6HicbVBNS8NAEJ3Ur1q/qh69rBbBU0mqoMeCF48t2FpoQ9lsJ+3azSbsboQS+gu8eFDEqz/Jm//GbZuDtj4YeLw3w8y8IBFcG9f9dgpr6xubW8Xt0s7u3v5B+fCoreNUMWyxWMSqE1CNgktsGW4EdhKFNAoEPgTj25n/8IRK81jem0mCfkSHkoecUWOl5mm/XHGr7hxklXg5qUCORr/81RvELI1QGiao1l3PTYyfUWU4Ezgt9VKNCWVjOsSupZJGqP1sfuiUnFtlQMJY2ZKGzNXfExmNtJ5Ege2MqBnpZW8m/ud1UxPe+BmXSWpQssWiMBXExGT2NRlwhcyIiSWUKW5vJWxEFWXGZlOyIXjLL6+Sdq3qXVZrzatKneRxFOEEzuACPLiGOtxBA1rAAOEZXuHNeXRenHfnY9FacPKZY/gD5/MHWXGMhw== !

C AAAB6HicbVBNS8NAEJ34WetX1aOXxSJ4KkkV9FjoxWML9gPaUDbbSbt2swm7G6GE/gIvHhTx6k/y5r9x2+agrQ8GHu/NMDMvSATXxnW/nY3Nre2d3cJecf/g8Oi4dHLa1nGqGLZYLGLVDahGwSW2DDcCu4lCGgUCO8GkPvc7T6g0j+WDmSboR3QkecgZNVZq1gelsltxFyDrxMtJGXI0BqWv/jBmaYTSMEG17nluYvyMKsOZwFmxn2pMKJvQEfYslTRC7WeLQ2fk0ipDEsbKljRkof6eyGik9TQKbGdEzVivenPxP6+XmvDOz7hMUoOSLReFqSAmJvOvyZArZEZMLaFMcXsrYWOqKDM2m6INwVt9eZ20qxXvulJt3pRrJI+jAOdwAVfgwS3U4B4a0AIGCM/wCm/Oo/PivDsfy9YNJ585gz9wPn8AjPmMqQ== AAAB6HicbVBNS8NAEJ34WetX1aOXxSJ4KkkV9FjoxWML9gPaUDbbSbt2swm7G6GE/gIvHhTx6k/y5r9x2+agrQ8GHu/NMDMvSATXxnW/nY3Nre2d3cJecf/g8Oi4dHLa1nGqGLZYLGLVDahGwSW2DDcCu4lCGgUCO8GkPvc7T6g0j+WDmSboR3QkecgZNVZq1gelsltxFyDrxMtJGXI0BqWv/jBmaYTSMEG17nluYvyMKsOZwFmxn2pMKJvQEfYslTRC7WeLQ2fk0ipDEsbKljRkof6eyGik9TQKbGdEzVivenPxP6+XmvDOz7hMUoOSLReFqSAmJvOvyZArZEZMLaFMcXsrYWOqKDM2m6INwVt9eZ20qxXvulJt3pRrJI+jAOdwAVfgwS3U4B4a0AIGCM/wCm/Oo/PivDsfy9YNJ585gz9wPn8AjPmMqQ== C C X X l l

AAAB/3icbVDLSgMxFM3UV62vUUEEN8EiuChlpgq6LLpxWdE+oDOUTJppQzPJmGSUMnbhr7hxoYhbf8Odf2PazkJbD1w4nHMv994TxIwq7TjfVm5hcWl5Jb9aWFvf2Nyyt3caSiQSkzoWTMhWgBRhlJO6ppqRViwJigJGmsHgcuw374lUVPBbPYyJH6EepyHFSBupY+95SYykFA+l1FN3CZJkVLopXXTsolN2JoDzxM1IEWSodewvrytwEhGuMUNKtV0n1n6KpKaYkVHBSxSJER6gHmkbylFElJ9O7h/BI6N0YSikKa7hRP09kaJIqWEUmM4I6b6a9cbif1470eG5n1IeJ5pwPF0UJgxqAcdhwC6VBGs2NARhSc2tEPeRRFibyAomBHf25XnSqJTdk3Ll+rRY3c/iyIMDcAiOgQvOQBVcgRqoAwwewTN4BW/Wk/VivVsf09aclc3sgj+wPn8AxbOVyw== , ,S,B AAAB+3icbVDLSgMxFM3UV62vsW4EN9EiuChlpgqKq6IblxXtA9qhZNJMG5pJhiSjlmF+xY0LRdz6I+78G9N2Ftp64MLhnHu59x4/YlRpx/m2ckvLK6tr+fXCxubW9o69W2wqEUtMGlgwIds+UoRRThqaakbakSQo9Blp+aPrid96IFJRwe/1OCJeiAacBhQjbaSeXezGEZJSPJaTw7R8V2aXVz275FScKeAicTNSAhnqPfur2xc4DgnXmCGlOq4TaS9BUlPMSFroxopECI/QgHQM5Sgkykumt6fw2Ch9GAhpims4VX9PJChUahz6pjNEeqjmvYn4n9eJdXDhJZRHsSYczxYFMYNawEkQsE8lwZqNDUFYUnMrxEMkEdYmroIJwZ1/eZE0qxX3tFK9PSvV9rM48uAAHIET4IJzUAM3oA4aAIMn8AxewZuVWi/Wu/Uxa81Z2cwe+APr8wfL3ZN9 , !,S,l : B AAAB+XicbVBNS8NAEJ3Ur1q/ol4EL6tF8FBKUgU9Fr14rGg/oA1ls920SzfZsLuplNB/4sWDIl79J978N27bHLT1wcDjvRlm5vkxZ0o7zreVW1ldW9/Ibxa2tnd29+z9g4YSiSS0TgQXsuVjRTmLaF0zzWkrlhSHPqdNf3g79ZsjKhUT0aMex9QLcT9iASNYG6lr250kxlKKp1J6Mik9lG66dtEpOzOgZeJmpAgZal37q9MTJAlppAnHSrVdJ9ZeiqVmhNNJoZMoGmMyxH3aNjTCIVVeOrt8gs6M0kOBkKYijWbq74kUh0qNQ990hlgP1KI3Ff/z2okOrr2URXGiaUTmi4KEIy3QNAbUY5ISzceGYCKZuRWRAZaYaBNWwYTgLr68TBqVsntRrtxfFqtHWRx5OIZTOAcXrqAKd1CDOhAYwTO8wpuVWi/Wu/Uxb81Z2cwh/IH1+QN6KJLD , !,S,B

AAAB+XicbVBNS8NAEJ3Ur1q/ol4EL6tF8FBKUgU9Fr14rGg/oA1ls920SzfZsLuplNB/4sWDIl79J978N27bHLT1wcDjvRlm5vkxZ0o7zreVW1ldW9/Ibxa2tnd29+z9g4YSiSS0TgQXsuVjRTmLaF0zzWkrlhSHPqdNf3g79ZsjKhUT0aMex9QLcT9iASNYG6lr250kxlKKp1J6Mik9lG66dtEpOzOgZeJmpAgZal37q9MTJAlppAnHSrVdJ9ZeiqVmhNNJoZMoGmMyxH3aNjTCIVVeOrt8gs6M0kOBkKYijWbq74kUh0qNQ990hlgP1KI3Ff/z2okOrr2URXGiaUTmi4KEIy3QNAbUY5ISzceGYCKZuRWRAZaYaBNWwYTgLr68TBqVsntRrtxfFqtHWRx5OIZTOAcXrqAKd1CDOhAYwTO8wpuVWi/Wu/Uxb81Z2cwh/IH1+QN6KJLD , !,S,B AAAB+3icbVDLSgMxFM3UV62vsW4EN9EiuChlpgqKq6IblxXtA9qhZNJMG5pJhiSjlmF+xY0LRdz6I+78G9N2Ftp64MLhnHu59x4/YlRpx/m2ckvLK6tr+fXCxubW9o69W2wqEUtMGlgwIds+UoRRThqaakbakSQo9Blp+aPrid96IFJRwe/1OCJeiAacBhQjbaSeXezGEZJSPJaTw7R8V2aXVz275FScKeAicTNSAhnqPfur2xc4DgnXmCGlOq4TaS9BUlPMSFroxopECI/QgHQM5Sgkykumt6fw2Ch9GAhpims4VX9PJChUahz6pjNEeqjmvYn4n9eJdXDhJZRHsSYczxYFMYNawEkQsE8lwZqNDUFYUnMrxEMkEdYmroIJwZ1/eZE0qxX3tFK9PSvV9rM48uAAHIET4IJzUAM3oA4aAIMn8AxewZuVWi/Wu/Uxa81Z2cwe+APr8wfL3ZN9 , !,S,l : B AAAB+XicbVBNS8NAEJ3Ur1q/ol4EL6tF8FBKUgU9Fr14rGg/oA1ls920SzfZsLuplNB/4sWDIl79J978N27bHLT1wcDjvRlm5vkxZ0o7zreVW1ldW9/Ibxa2tnd29+z9g4YSiSS0TgQXsuVjRTmLaF0zzWkrlhSHPqdNf3g79ZsjKhUT0aMex9QLcT9iASNYG6lr250kxlKKp1J6Mik9lG66dtEpOzOgZeJmpAgZal37q9MTJAlppAnHSrVdJ9ZeiqVmhNNJoZMoGmMyxH3aNjTCIVVeOrt8gs6M0kOBkKYijWbq74kUh0qNQ990hlgP1KI3Ff/z2okOrr2URXGiaUTmi4KEIy3QNAbUY5ISzceGYCKZuRWRAZaYaBNWwYTgLr68TBqVsntRrtxfFqtHWRx5OIZTOAcXrqAKd1CDOhAYwTO8wpuVWi/Wu/Uxb81Z2cwh/IH1+QN6KJLD , !,S,B ⇤ " " " " " " Figure 11 Copying rewrites

with the port i so that it can be used by other dataflow graph manipulating operations. The r-rules: compute the dependency (‘root’) of a graph. There are three versions of

the rule (r, r0, r00) depending on whether the requested dependency is incoming to a contraction, constant, or some other node. In all cases the token ‘jumps’ to the incoming port of the cell, labelled by i. Note that this rule is ‘non-local’, involving edge i located in some arbitrary point in the graph. The node which is at the nock of the arrow is irrelevant and it is not shown. The op-rules: compute operators by replacing the operation node with the resulting value as returned by the token and left on S. This is very similar to how stack machines generally evaluate operators. The outgoing ports of the operator are detached from the graph via weakening. The a-rule: implements assignment. A port i is left at the top of S along with a com- puted integer m (in the form (m, i)). The result of the assignment operation is unit () but the value of the cell with incoming port x is updated to m. The l-rule: implements linking. At the top of S there is a port x (tagged as l(i)). The operation returns (), like assignment, but the outgoing port of the cell pointed at by port i is reassigned to the second argument i of a. The i f -rule: depending on the previous pass rule, if the token is sent to the first branch the second branch is disconnected by linking the port to a weakening, and vice-versa. In both cases the node if is removed. Finally, copying rules are given in figure 11.

12:16 Steven W.T. Cheung, Dan R. Ghica, and Koko Muroya

The Cc rule: combines two consecutive m-ary and n-ary contraction nodes in a single m + n-ary contraction node. The C rule: (for a node X = C) resets the f flag. This is not a ‘pass’ rule, even though the underlying graph does6 not change, because the token stays put. This happens with some other rules for contraction. The C-! rule: removes redundant ‘unary’ contractions. The X-! rule: (for a node x = C) resets the f flag. 6 The δ rule: is the the main rule of the contraction node, and it leads to the copying of the box just above it. Note that this is the main purpose of boxes, to delimit copyable sub-graphs for copying by the contraction node. The µ-rule: is not a contraction rule, but it is very similar. It represents the ‘unfolding’ of a recursive call by copying the body G.

3.6 Dataflow computation

In contrast to the graphs representing programs, graphs representing dataflow are much simpler and includes only nodes for operators ($), if statements, and dereferencing (d). The pass and rewrite rules are given in table 2. To indicate the datflow-mode for operators the flag g is placed at the top of the stack. The d pass rule: represents the dereferencing operator, which records on the stack S the value n stored at a cell i. The $-operator pass rule: picks up the values of the branches m, n from the top of the stack and replace them with the value of the operator as applied to them $ m n. The tags x, y , g but at least one should be g. This is because we want to mix constant nodes∈ {− into} the dataflow graph, and they result ina tag, whereas cells result in a g tag. If both of them are it means that there is a− sub-graph made just of constants, which should have been− evaluated during graph construction. The if pass rule: implements the behaviour of branching in the datflow graph. Unlike an if statement in the graph-construction mode, which chooses one branch, in dataflow mode both branches are evaluated and only one value is selected, asseen in the final two rules, where X , Y represent any element of the stack. Additionally, some of the pass rules from table 1 apply to dataflow computation as well, unchanged (namely constants n, cells n , operators ω, if and !). The if-rule for dataflow is inefficient,{ }but it is required↑ for soundness becauseof conditional graph constructions. Consider the code:

let x = ref 1 in ref(if x < 2 then f 3 else f 4) If only one side is evaluated then when x is possibly changed to 2 then f 4 would need to be evaluated. So instead of rewriting the if node, because it is part of a dataflow graph, it is left in the dataflow graph under the proviso that wealways need to evaluate both sides. An optimised version of the rule which only evaluates one branch could be written, but it is more complicated. Moreover, the inefficiencies introduced here do not change the asymptotic complexity of graph evaluation, as will be seen shortly.

12:17 Transparent Synchronous Dataflow

Table 2 Dataflow rules

node e d f S e d f S 7→ d o0 (n, i):S i0 (n, g):S ↓ ↓ $ o0 $ (m, x) : (n, y):S i0 $ ($ m n, g):S ↓ ↓ if o0 (0, g):S o1 ? : if0:S ↓ ↑ if o0 (n = 0, g):S o1 ? : if1:S ↓ 6 ↑ if o2 X : Y : if0:S i0 X :S ↓ ↓ if o2 X : Y : if1:S i0 Y :S ↓ ↓ $ i0 $ (n, g):S i0 (n, g):S ↓ ↓

For evaluating dataflow graphs we use a different set of tokens called prop-tokens. Each such evaluation starts with an initial set of initial prop tokens and concludes with a set of final prop tokens.

Definition 3.3 (Initial prop-tokens). We define the set of initial prop tokens InitP as (e0, , , ? : , ), ...(en, , , ? : , ) , where e0...en is the set of outputs of all n {-nodes↑ in the graph. ↑ } { } { } P Definition 3.4 (Final prop-tokens). We define the set of final prop tokens Final (X~) as (e0, , , X0 : , )...(en, , , Xn : , ) , where e0...en is the set of outputs of all { ↓ ~ ↓ } { } n -nodes in the graph, X = X0, ..., Xn and X0, ..., Xn are elements of the computation stack.{ } { }

When the token hits a step node, the machine switches from evaluation mode to propagation mode.

Definition 3.5 (Mode switching). We define the following special transitions: P 1. (G, (e, , , ? : S, B), ) (G, (e, , sp, ? : S, B), Init ) triggering the propagation when e↑ is the incoming; 7→ port of an↑ s-node , and P ~ s 2. (G, (e, , sp, ? : S, B), Final (X )) (G0, (e, , s, (b, ) : S, B), ) terminating the propagation↑ as follows: for any n 7→-node in G↓, let the− return; value of the eval token { } sitting on its output be (n0, x), then if n = n0, the n -node is updated to n0 in G0. The value of b is 1 if there are updates and6 0 otherwise{ } where 1, 0 Int.{ } ∈ Definition 3.6 (Propagations). We define a propagation as any transition from (G, δ, P) picking any non-final prop token to proceed using any possible transitions.

Definition 3.7 (Initial and final states). For any graph G : Λ Γ , any e dom(Λ) and any element X in the computation stack, we define the initial→ states∈ and final states as Init(G, e) = (G, e, , , ? : , , ) and Final(G, e, X ) = (G, e, , , X : , , ) respectively. ↑ ; ↓ ;

The DGOI machine executes terms by encoding them into computation graphs according to the definitions in figure 8, where the translation of a well-typed term, is denoted by Γ t : τ . An execution is any sequence of transitions starting from the initial state.J An` executionK is said to terminate if the execution ends with the final

12:18 Steven W.T. Cheung, Dan R. Ghica, and Koko Muroya

state, i.e. Init(G, r) ∗ Final(G0, r, X ) for some G0, X . An execution is said to be safe if it terminates or at any7→ state there is an applicable rule. They are formally defined in appendix D.10.

Remark. Much like the language itself, the graph-rewriting semantics is bi-modal, with pass and rewrite rules. The pass rules, even though they do not change the underlying graph, can still change the token. By inspecting the value of the token the semantics realises a kind of novel “semantic contextualisation” which allows certain rules to be applied in a different way depending on the execution history of the program. For example, operators can have either a pass or a rewriting semantics depending on the data in the token, which records whether the operator must be reduced or kept into a DFG graph. This is the “secret sauce” which allows operators to behave in a contextual way without resorting to any syntactic trickery.

3.7 Overview of type soundness proofs

In the Appendix we prove a basic theorem of the calculus, namely the Type Soundness Theorem which states that a well-typed program will not crash.

Theorem 3.1 (Type soundness). Let G : r : τ = t : τ for some closed well- { J K} → ; J` K typed term t : τ. (1) If t is recursion-free then any execution from Init(G, r) terminates. (2) Otherwise,` the execution of t is at least safe.

In order to prove (1) termination, we first identify a special form of graph, dataflow graph. Any execution that runs on them will always terminate and the graph will remain unchanged since no rewrite ever happens. Throughout the execution, any cell will always be connected to a dataflow graph because of the nature of call-by-value. Therefore step-propagation always terminates and is confluent. As a result, all the non-deterministic propagation sequences can be seen as one single transition and thus making the machine deterministic. After that we can prove termination by using induction on type derivation. As for (2) safety, the proof is simply a case analysis on possible states. All the proof details can be found in appendices D.1 to D.10. Given the formulation of the semantics as an abstract machine we can immediately conclude that:

Theorem 3.2 (Efficiency). The following operations can be executed in linear time on the depth of the dataflow graph: cell creation, dereferencing, peeking, linking, assignment, root. The step operation can be executed in linear time on the depth of the dataflow graph and on the number of cells.

3.8 A non-trivial example

We conclude with a non-trivial example, computing a stream of prime numbers using the sieve of Eratosthenes. The code is in listing 1 and can be executed in the visualiser.3 It is interesting to contrast our code with the same program implemented

3 https://cwtsteven.github.io/TSD-visual?ex=primes

12:19 Transparent Synchronous Dataflow

Listing 1 A stream of prime numbers 1 let fromn = λn.let s = ref n in link s (s + 1); deref s in 2 let filter = λinp. λn.i == n || ((i % n) <> 0) in 3 let inp = fromn 2 in 4 let sieve = ref (filter inp 2) in 5 let next = λ_. step; link sieve (root sieve && (filter inp (peek inp))) in 6 let delay = ref inp in 7 let primes = if deref sieve then delay else 0 in 8 next 0; peek primes; // return 2 9 next 0; peek primes; // return 3 10 next 0; peek primes // return 0

1 1

+ + {3} inp {2} inp C C

AAACGHicbVDLSsNAFJ34rPUVdSO6GSyCq5JUQZcFNy4r2Ac0oUwmk3bozCTMTIQQCn6HH+BWP8GduHXnF/gbTtosbOuBgcM553LnniBhVGnH+bZWVtfWNzYrW9Xtnd29ffvgsKPiVGLSxjGLZS9AijAqSFtTzUgvkQTxgJFuML4t/O4jkYrG4kFnCfE5GgoaUYy0kQb2icdMOESQiqQeUaaJ9AruwcbArjl1Zwq4TNyS1ECJ1sD+8cIYp5wIjRlSqu86ifZzJDXFjEyqXqpIgvAYDUnfUIE4UX4+vWECz40SwiiW5gkNp+rfiRxxpTIemCRHeqQWvUL8z+unOrrxc3NSqonAs0VRyqCOYVEIDKkkWLPMEIQlNX+FeIQkwqaK+S1KcyQzGU5MM+5iD8uk06i7l/XG/VWteVx2VAGn4AxcABdcgya4Ay3QBhg8gRfwCt6sZ+vd+rA+Z9EVq5w5AnOwvn4Bm8igMw== inp.filter inp 2 AAACA3icbVDLSsNAFL3xWesr6kZ0M1gEVyFpBV0W3LisYB/QhDKZTNqhkwczE6GEght/xY0LRdz6E+78GydtFtp6YOBwzrncucdPOZPKtr+NldW19Y3NylZ1e2d3b988OOzIJBOEtknCE9HzsaScxbStmOK0lwqKI5/Trj++KfzuAxWSJfG9mqTUi/AwZiEjWGlpYJ64XIcDjFicWiHjigq34C5qDMyabdkzoGXilKQGJVoD88sNEpJFNFaEYyn7jp0qL8dCMcLptOpmkqaYjPGQ9jWNcUSll89umKJzrQQoTIR+sUIz9fdEjiMpJ5GvkxFWI7noFeJ/Xj9T4bWX65MyRWMyXxRmHKkEFYWggAlKFJ9ogolg+q+IjLDARFchq7oEZ/HkZdKpW07Dqt9d1prHZR0VOIUzuAAHrqAJt9CCNhB4hGd4hTfjyXgx3o2PeXTFKGeO4A+Mzx/I4JbT inp.filter inp 3

if if

primes primes

Figure 12 before and after next()

in a similar language, Lucid Synchrone4 (appendix B). The main distinction is that we use imperative commands to set up the dataflow graph, whereas in Lucid Synchrone co-recursive stream equations are used to the same purpose. It is a matter of preference which one of the two versions are seen as more accessible. In listing 1, the function fromn takes an integer n and creates a stream of integers from n. The function filter takes an input stream inp and an integer n and creates a stream of booleans that could filter out the multiples of n (except for n itself) and anything smaller than n from inp. This filter function is meant to create the different layers of sieve that are used in generating prime numbers. To implement the sieve of Eratosthenes, we first start with an input stream using fromn 2 (named inp). A cell is then initialised with the first layer filter inp 2. The sieve needs to expand by adding new layers of sieve in every step, without rewriting the dataflow graph. The solution is to use the function next which unfolds a layer after each step as shown in figure 12. Finally since sieve is a cell that depends on inp meaning that it is always one step behind inp and thus primes = if sieve then inp else 0 would not gives the correct stream. Instead we need to create a delayed stream from inp (delay = ref inp) in order to synchronise the input of primes, i.e. primes = if sieve then delay else 0. Table 3 shows the first few elements of each stream.

4 https://www.di.ens.fr/~pouzet/lucid-synchrone/manual_html/manual015.html

12:20 Steven W.T. Cheung, Dan R. Ghica, and Koko Muroya

Table 3 Streams of the sieve program

step 0 1 2 3 4 5 6 7 ··· inp 2 3 4 5 6 7 8 9 sieve t t t f t f t f ··· delay 2 2 3 4 5 6 7 8 ··· primes 2 2 3 0 5 0 7 0 ··· ···

4 Experimental implementation

We have proved that TSD is efficient “in principle” by examining its abstract machine execution. But we also want to gather some practical evidence that the mechanism we propose is not hopelessly inefficient. For that, we implement the calculus asa library module for OCaml (TSD), together with a PPX language extension.5 The library serves as an embedded DSL, which is blended into the host language more seamlessly via the language extension. Note that the semantics defined earlier is used asa specification, and is not realised faithfully by the implementation. As such, theOCaml implementation does not benefit fully from the potential to seamlessly integrate the DFG and functional syntax and semantics. A full implementation based directly on the abstract machine is a more substantial endeavour which we leave as further work. Details of the implementation are in appendix C, where we also give comparisons between TSD and related programming languages, both in terms of programming style and in terms of benchmarks (appendix C.1).

5 Related work

The broadest context of our work is dataflow programming, which has been extensively studied ([31] is a relatively recent, exhaustive survey). Besides the numerous FRP frameworks, some of the ideas we present here are particularly prominent in functional hardware-description languages which allow (meta) programming synchronous dataflow, including in a transparent style if so desired [5]. Advances in dataflow programming materialised into the success of notable languages such as Lucid [53] or Lustre [28], but the influence of the dataflow style of programming was far broader, as seen for example in the popular machine-learning library TensorFlow, which is presented commonly as a embedded domain specific dataflow language (EDSL) in Python [1].

Functional reactive programming We are particularly concerned with dataflow programming in a functional style, the so-called functional reactive programming [18, 30, 47, 54] which proved to be especially well suited for Haskell because of its lazy style of computation, its expressive type system, and syntactic features which allows the convenient design and implementation of EDSLs ([8] is a recent textbook).

5 https://github.com/cwtsteven/TSD

12:21 Transparent Synchronous Dataflow

FrTime [15] is a functional reactive programming language embedded into Scheme. It also provides transparent graph creation by inserting code for operators such as {+, -} to check in runtime if their arguments are signals or ordinary Scheme values. This makes use of the fact that Scheme is dynamically typed. The graph creation mechanism in TSD is very much similar but the choice of creating a graph or to create a normal constant is captured in the rewriting rules of the node instead. It can be seen as one of the implementation techniques of transparent graph creation. There is also a difference to the model of change propagation between them. FrTime embraces a push-driven implementation where signal changes are pushed to the dataflow network immediately. On the contrary, TSD can be seen as a mixedof push and pull implementation. For immediate dependency (without cells) they are pull-driven and their values are recomputed on demand. Whereas for cells, they will be updated via step which is push-driven. By having explicit step command and pull-driven immediate dependencies, we avoid the glitch problem that arises in all push-driven implementations. Flapjax [42] is another FRP language based on FrTime but it is embedded into JavaScript. AmbientTalk/R [11] is another push-based reactive programming framework similar to FrTime that is built on top of AmbientTalk. Like FrTime, expressions in AmbientTalk/R are implicitly lifted such that graphs are created transparently. AmbientTalk/R also supports distributed reactive programming where reactive values can be distributed in various hosts. We are also interested in designing a distributed model for TSD where cells can be allocated in different machines but this is left for further investigation. REScala [52] is an EDSL built on top of Scala that bridges between object-oriented and function style in reactive programming. It provides two abstractions for reactive programming, signals and events. The input of dataflow graph in REScala is called a Var which can be set or transform to other values. Signals are created using Vars and other signals. Whereas in TSD, cells are not just the input of a graph but it also represents a state in the graph. The dependency of cells can also be reconfigured using link which allows the graph to be cyclic. On the other hand, cyclic dependencies will lead to runtime error in REScala. Moreover, change propagation in REScala is also push-based. A somewhat parallel but relevant line of research is the use of temporal type systems to restrict reactive computation to (space) efficient programs [33, 34, 35]. Inthis approach the type of streams remains exposed, so the programmer can write more expressive, lower-level (in the sense of controlling events and streams) programs, but such programs must conform to a typing discipline which guarantees certain space-utilisation constraints. In contrast, our approach is higher-level— less expressive but more convenient for the unsophisticated programmer. In TSD the complexity is pushed down to the level of the abstract machine, whereas in loc. cit. a complex temporal typing discipline is imposed on a conventional operational semantics.

Self-adjusting computation Self-adjusting computation has been introduced by Acar [3] and studied extensively in recent years. The use of SAC as a transparent dataflow idiom, which features quite prominently in our motivating introduction, has not been studied formally, although it has been mentioned [29] and it has been extensively

12:22 Steven W.T. Cheung, Dan R. Ghica, and Koko Muroya discussed in informal fora.6 In terms of implementation, SAC is a good match for incremental computation [49], which is a sophisticated memoisation infrastructure which allows the re-evaluation of expressions that need to be re-evaluated, thus saving computation (see also [50] for a survey). As most optimisations, incremental computation relies on a trade-off between saving the cost of unnecessary re-evaluations on the one hand versus maintaining the memoisation infrastructure, which is not free [10]. We are providing two implementations, incremental and non-incremental, and indeed the performance gains are quite dependent on the particular application.

Synchronous dataflow languages Also related is the significant body of work on synchronous dataflow programming languages and their semantics (e.g. Esterel [7]) and in particular functional languages (e.g. Lucid Synchrone [13], a functional version of Lustre [28]). These are the most similar languages to TSD, with some significant distinctions: TSD constructs the dataflow model using imperative features, and it does not aim at real-time execution, so it does not employ a clock calculus. Also, TSD dataflow graphs are productive by construction, since cyclic links can onlybe constructed via cells. So productivity checks are not necessary. RML [41] is a low level synchronous extension to OCaml, consisting of a set of primitives for sending and handling messages. We say ‘low level’ because it is very easy to write unsafe programs in RML, e.g. two processes waiting for each other to emit a signal. Reactive ML has in common with the TSD language the fact that they build on the ML language, as a stand-alone compiler in their case versus a PPX extension in ours. Our work is conceptually related to such languages in the way that SAC is related to (asynchronous) FRP.

Geometry of interaction The DGOIM is a graph-rewriting system based on the Ge- ometry of Interaction (GOI) [25], an interpretation of proofs in linear logic as proof nets [26]. The GOI was formulated as a compositional operational semantics of com- municating transducers and used to interpret higher-order functional programming languages [39]. The GOI approach turned out to be particularly useful for compiling conventional languages to unconventional architectures (such as reconfigurable circuits [23], distributed [21], or quantum architectures [36]). It has also been used to give strikingly space-efficient compilation schemes [38] and improved time-efficiency by incorporating graph rewriting in addition to token-passing [19, 20]. The extension of the GOI machine with simple rewriting rules, the so-called Dynamic GOI machine has allowed the definition of an efficient (space and time) abstract machine for CBN, CBV and lazy (a la Haskell) evaluations [45]. This flexibility and uniformity in representing several evaluation strategies in the same machine allows a natural specification for languages that require it, such as TSD. Moreover, the computational intuitions of the approach combine seamlessly dataflow and higher-order features, making it suitable for the study of languages that require it, such as TensorFlow [14, 44].

6 See e. g. https://blog.janestreet.com/introducing-incremental/

12:23 Transparent Synchronous Dataflow

6 Conclusion

In this paper we have introduced a new programming idiom, transparent synchronous dataflow programming (TSD). This programming idiom is natural, allowing a high- level of abstraction to be applied to useful synchronous algorithms. We define TSD using the relatively new diagrammatic operational style of token- guided graph rewriting. Although inspired by the Geometry of Interaction this dynamic mechanism is in many a significant departure from the strictures of GOI. It is arguably intuitive, as the graphical formalism is a natural setting for the study of dataflow, which it neatly extends with higher-order features. Moreover, it has certain technical advantages, such as the fine-grained management of sharing or the decomposition of big syntactic reduction rules into atomic graph manipulations. The calculus TSD restricts cells to ground type. In order for multi-token (parallel) propagation to work dataflow graphs must be also pure in the sense that no rewrites are possible. Our solution is to prevent the presence of lambda-nodes in computation graphs. This is done for the sake of simplicity. We already know that DGOIM can be used to give CBN evaluation on a fixed graph including lambda-nodes, so an extension to higher-order TSD is likely to be possible. On the other hand, extensions with effects are more problematic as the extension of DGOIM with effects, in general, is a matter of active research. Our PPX language extension to OCaml implementing the calculus does not take advantage of parallel evaluation of propagation or optimisation beyond basic incrementalisation. It is mainly a proof-of-concept implementation that shows that the ideas are implementable (even naively). But efficient implementations are high on our agenda.

Acknowledgements The authors want to thank Neel Krishnaswami for discussions and encouragement.

References

[1] Martín Abadi, Paul Barham, Jianmin Chen, Zhifeng Chen, Andy Davis, Jef- frey Dean, Matthieu Devin, Sanjay Ghemawat, Geoffrey Irving, Michael Isard, Manjunath Kudlur, Josh Levenberg, Rajat Monga, Sherry Moore, Derek Gor- don Murray, Benoit Steiner, Paul A. Tucker, Vijay Vasudevan, Pete Warden, Martin Wicke, Yuan Yu, and Xiaoqiang Zheng. “TensorFlow: A System for Large-Scale Machine Learning”. In: 12th USENIX Symposium on Operating Sys- tems Design and Implementation, OSDI 2016, Savannah, GA, USA, November 2-4, 2016. Edited by Kimberly Keeton and Timothy Roscoe. USENIX Association, 2016, pages 265–283. url: https://www.usenix.org/conference/osdi16/technical- sessions/presentation/abadi. [2] Umut A. Acar, Amal Ahmed, and Matthias Blume. “Imperative self-adjusting computation”. In: Proceedings of the 35th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, POPL 2008, San Francisco, California,

12:24 Steven W.T. Cheung, Dan R. Ghica, and Koko Muroya

USA, January 7-12, 2008. Edited by George C. Necula and Philip Wadler. ACM, 2008, pages 309–322. doi: 10.1145/1328438.1328476. [3] Umut A. Acar, Matthias Blume, and Jacob Donham. “A consistent semantics of self-adjusting computation”. In: Journal of Functional Programming 23.3 (2013), pages 249–292. doi: 10.1017/S0956796813000099. [4] Beniamino Accattoli. “The Complexity of Abstract Machines”. In: Proceedings Third International Workshop on Rewriting Techniques for Program Transforma- tions and Evaluation, WPTE@FSCD 2016, Porto, Portugal, 23rd June 2016. 2016, pages 1–15. doi: 10.4204/EPTCS.235.1. [5] Christiaan Baaij, Matthijs Kooijman, Jan Kuper, Arjan Boeijink, and Marco Gerards. “C?aSH: Structural Descriptions of Synchronous Hardware Using Haskell”. In: 13th Euromicro Conference on Digital System Design, Architectures, Methods and Tools, DSD 2010, 1-3 September 2010, Lille, France. Edited by Sebastián López. IEEE Computer Society, 2010, pages 714–721. doi: 10.1109/ DSD.2010.21. [6] Atilim Gunes Baydin, Barak A. Pearlmutter, Alexey Andreyevich Radul, and Jeffrey Mark Siskind. “Automatic Differentiation in Machine Learning: aSur- vey”. In: Journal of Machine Learning Research 18 (2017), 153:1–153:43. url: http://jmlr.org/papers/v18/17-468.html. [7] Gérard Berry and Laurent Cosserat. “The ESTEREL Synchronous Program- ming Language and its Mathematical Semantics”. In: Seminar on Concurrency, Carnegie-Mellon University, Pittsburg, PA, USA, July 9-11, 1984. Edited by Stephen D. Brookes, A. W. Roscoe, and Glynn Winskel. Volume 197. Lecture Notes in Computer Science. Springer, 1984, pages 389–448. doi: 10.1007/3-540-15670- 4_19. [8] Stephen Blackheath and Anthony Jones. Functional reactive programming. Man- ning Publications Company, 2016. isbn: 978-1-63343-010-5. [9] Sylvain Boulmé and Grégoire Hamon. “Certifying Synchrony for Free”. In: Logic for Programming, Artificial Intelligence, and Reasoning, 8th International Conference, LPAR 2001, Havana, Cuba, December 3-7, 2001, Proceedings. 2001, pages 495–506. doi: 10.1007/3-540-45653-8_34. [10] Sebastian Burckhardt, Daan Leijen, Caitlin Sadowski, Jaeheon Yi, and Thomas Ball. “Two for the price of one: a model for parallel and incremental computation”. In: Proceedings of the 26th Annual ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications, OOPSLA 2011, part of SPLASH 2011, Portland, OR, USA, October 22 - 27, 2011. Edited by Cristina Videira Lopes and Kathleen Fisher. ACM, 2011, pages 427–444. doi: 10.1145/2048066.2048101. [11] Andoni Lombide Carreton, Stijn Mostinckx, Tom Van Cutsem, and Wolfgang De Meuter. “Loosely-Coupled Distributed Reactive Programming in Mobile Ad Hoc Networks”. In: Objects, Models, Components, Patterns, 48th International Conference, TOOLS 2010, Málaga, Spain, June 28 - July 2, 2010. Proceedings.

12:25 Transparent Synchronous Dataflow

Edited by Jan Vitek. Volume 6141. Lecture Notes in Computer Science. Springer, 2010, pages 41–60. doi: 10.1007/978-3-642-13953-6_3. [12] Paul Caspi, Daniel Pilaud, Nicolas Halbwachs, and John Plaice. “Lustre: A Declarative Language for Programming Synchronous Systems”. In: Conference Record of the Fourteenth Annual ACM Symposium on Principles of Programming Languages, Munich, Germany, January 21-23, 1987. 1987, pages 178–188. doi: 10.1145/41625.41641. [13] Paul Caspi and Marc Pouzet. “Synchronous Kahn Networks”. In: Proceedings of the 1996 ACM SIGPLAN International Conference on Functional Programming, ICFP 1996, Philadelphia, Pennsylvania, USA, May 24-26, 1996. Edited by Robert Harper and Richard L. Wexelblat. ACM, 1996, pages 226–238. doi: 10.1145/ 232627.232651. [14] Steven Cheung, Victor Darvariu, Dan R. Ghica, Koko Muroya, and Reuben N. S. Rowe. “A Functional Perspective on Machine Learning via Programmable Induction and Abduction”. In: Functional and Logic Programming - 14th Inter- national Symposium, FLOPS 2018, Nagoya, Japan, May 9-11, 2018, Proceedings. 2018, pages 84–98. doi: 10.1007/978-3-319-90686-7_6. [15] Gregory H. Cooper and Shriram Krishnamurthi. “Embedding Dynamic Dataflow in a Call-by-Value Language”. In: Programming Languages and Systems, 15th European Symposium on Programming, ESOP 2006, Held as Part of the Joint European Conferences on Theory and Practice of Software, ETAPS 2006, Vienna, Austria, March 27-28, 2006, Proceedings. Edited by Peter Sestoft. Volume 3924. Lecture Notes in Computer Science. Springer, 2006, pages 294–308. doi: 10. 1007/11693024_20. [16] James B Dabney and Thomas L Harman. Mastering simulink. Pearson, 2004. isbn: 978-0-13-017085-9. [17] Vincent Danos and Laurent Regnier. “Reversible, Irreversible and Optimal lambda-Machines”. In: Theoretical Computer Science 227.1-2 (1999), pages 79– 97. doi: 10.1016/S0304-3975(99)00049-3. [18] Conal Elliott and Paul Hudak. “Functional Reactive Animation”. In: Proceedings of the 1997 ACM SIGPLAN International Conference on Functional Programming (ICFP ’97), Amsterdam, The Netherlands, June 9-11, 1997. Edited by Simon L. Peyton Jones, Mads Tofte, and A. Michael Berman. ACM, 1997, pages 263– 273. doi: 10.1145/258948.258973. [19] Maribel Fernández and Ian Mackie. “Call-by-Value lambda-Graph Rewriting Without Rewriting”. In: Graph Transformation, First International Conference, ICGT 2002, Barcelona, Spain, October 7-12, 2002, Proceedings. Edited by An- drea Corradini, Hartmut Ehrig, Hans-Jörg Kreowski, and Grzegorz Rozenberg. Volume 2505. Lecture Notes in Computer Science. Springer, 2002, pages 75–89. doi: 10.1007/3-540-45832-8_8.

12:26 Steven W.T. Cheung, Dan R. Ghica, and Koko Muroya

[20] Maribel Fernández and Ian Mackie. “From Term Rewriting to Generalised Interaction Nets”. In: Programming Languages: Implementations, Logics, and Programs, 8th International Symposium, PLILP’96, Aachen, Germany, September 24-27, 1996, Proceedings. Edited by Herbert Kuchen and S. Doaitse Swierstra. Volume 1140. Lecture Notes in Computer Science. Springer, 1996, pages 319– 333. doi: 10.1007/3-540-61756-6_94. [21] Olle Fredriksson and Dan R. Ghica. “Seamless Distributed Computing from the Geometry of Interaction”. In: Trustworthy Global Computing - 7th International Symposium, TGC 2012, Newcastle upon Tyne, UK, September 7-8, 2012, Revised Selected Papers. Edited by Catuscia Palamidessi and Mark Dermot Ryan. Vol- ume 8191. Lecture Notes in Computer Science. Springer, 2012, pages 34–48. doi: 10.1007/978-3-642-41157-1_3. [22] Felix A. Gers, Jürgen Schmidhuber, and Fred A. Cummins. “Learning to For- get: Continual Prediction with LSTM”. In: Neural Computation 12.10 (2000), pages 2451–2471. doi: 10.1162/089976600300015015. [23] Dan R. Ghica. “Geometry of synthesis: a structured approach to VLSI design”. In: Proceedings of the 34th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, POPL 2007, Nice, France, January 17-19, 2007. Edited by Martin Hofmann and Matthias Felleisen. ACM, 2007, pages 363–375. doi: 10.1145/1190216.1190269. [24] Dan R. Ghica, Koko Muroya, and Todd Waugh Ambridge. “Local Reasoning for Robust Observational Equivalence”. 2019. arXiv: 1907.01257 [cs.PL]. [25] Jean-Yves Girard. “Geometry of Interaction 1: Interpretation of System F”. In: Logic Colloquium ’88. Edited by R. Ferro, C. Bonotto, S. Valentini, and A. Zanardo. Volume 127. Studies in Logic and the Foundations of Mathematics. Elsevier, 1989, pages 221–260. doi: 10.1016/S0049-237X(08)70271-4. [26] Jean-Yves Girard. “Linear Logic: its syntax and semantics”. In: Advances in Linear Logic. Edited by Jean-Yves Girard, Yves Lafont, and LaurentEditors Regnier. London Mathematical Society Lecture Note Series. Cambridge University Press, 1995, pages 1–42. doi: 10.1017/CBO9780511629150.002. [27] Andreas Griewank. “On automatic differentiation”. In: Mathematical Program- ming: recent developments and applications. KTK Scientific, 1989, pages 83–107. isbn: 978-0-7923-0490-6. [28] Nicolas Halbwachs, Paul Caspi, Pascal Raymond, and Daniel Pilaud. “The synchronous data flow programming language LUSTRE”. In: Proceedings of the IEEE 79.9 (1991), pages 1305–1320. doi: 10.1109/5.97300. [29] Matthew A. Hammer, Khoo Yit Phang, Michael Hicks, and Jeffrey S. Foster. “Adapton: Composable, Demand-driven Incremental Computation”. In: Proceed- ings of the 35th ACM SIGPLAN Conference on Programming Language Design and Implementation. PLDI ’14. Edinburgh, United Kingdom: ACM, 2014, pages 156– 166. isbn: 978-1-4503-2784-8. doi: 10.1145/2594291.2594324.

12:27 Transparent Synchronous Dataflow

[30] Paul Hudak, Antony Courtney, Henrik Nilsson, and John Peterson. “Arrows, Robots, and Functional Reactive Programming”. In: Advanced Functional Pro- gramming, 4th International School, AFP 2002, Oxford, UK, August 19-24, 2002, Revised Lectures. Edited by Johan Jeuring and Simon L. Peyton Jones. Vol- ume 2638. Lecture Notes in Computer Science. Springer, 2002, pages 159–187. doi: 10.1007/978-3-540-44833-4_6. [31] Wesley M. Johnston, J. R. Paul Hanna, and Richard J. Millar. “Advances in dataflow programming languages”. In: ACM Computing Surveys 36.1 (2004), pages 1–34. doi: 10.1145/1013208.1013209. [32] Aleks Kissinger. “Pictures of Processes. Automated Graph Rewriting for Monoidal Categories and Applications to Quantum Computing”. PhD thesis. St. Cather- ine’s College, University of Oxford, 2011. arXiv: 1203.0202 [math.CT]. [33] Neelakantan R. Krishnaswami. “Higher-order functional reactive programming without spacetime leaks”. In: ACM SIGPLAN International Conference on Func- tional Programming, ICFP’13, Boston, MA, USA - September 25 - 27, 2013. 2013, pages 221–232. doi: 10.1145/2500365.2500588. [34] Neelakantan R. Krishnaswami and Nick Benton. “A semantic model for graphical user interfaces”. In: Proceeding of the 16th ACM SIGPLAN international conference on Functional Programming, ICFP 2011, Tokyo, Japan, September 19-21, 2011. 2011, pages 45–57. doi: 10.1145/2034773.2034782. [35] Neelakantan R. Krishnaswami, Nick Benton, and Jan Hoffmann. “Higher-order functional reactive programming in bounded space”. In: Proceedings of the 39th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, POPL 2012, Philadelphia, Pennsylvania, USA, January 22-28, 2012. 2012, pages 45– 58. doi: 10.1145/2103656.2103665. [36] Ugo Dal Lago, Claudia Faggian, Benoît Valiron, and Akira Yoshimizu. “The geometry of parallelism: classical, probabilistic, and quantum effects”. In: Pro- ceedings of the 44th ACM SIGPLAN Symposium on Principles of Programming Languages, POPL 2017, Paris, France, January 18-20, 2017. 2017, pages 833–845. doi: 10.1145/3009837.3009859. [37] Hai Liu and Paul Hudak. “Plugging a Space Leak with an Arrow”. In: Electronic Notes in Theoretical Computer Science 193 (2007), pages 29–45. doi: 10.1016/j. entcs.2007.10.006. [38] Ian Mackie. “Efficient lambda-Evaluation with Interaction Nets”. In: Rewriting Techniques and Applications, 15th International Conference, RTA 2004, Aachen, Germany, June 3-5, 2004, Proceedings. Edited by Vincent van Oostrom. Vol- ume 3091. Lecture Notes in Computer Science. Springer, 2004, pages 155–169. doi: 10.1007/978-3-540-25979-4_11. [39] Ian Mackie. “The Geometry of Interaction Machine”. In: Conference Record of POPL’95: 22nd ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, San Francisco, California, USA, January 23-25, 1995. 1995, pages 198– 208. doi: 10.1145/199448.199483.

12:28 Steven W.T. Cheung, Dan R. Ghica, and Koko Muroya

[40] Louis Mandel, Florence Plateau, and Marc Pouzet. “Lucy-n: a n-Synchronous Extension of Lustre”. In: Mathematics of Program Construction. Edited by Claude Bolduc, Jules Desharnais, and Béchir Ktari. Berlin, Heidelberg: Springer Berlin Heidelberg, 2010, pages 288–309. isbn: 978-3-642-13321-3. [41] Louis Mandel and Marc Pouzet. “ReactiveML: a reactive extension to ML”. In: Proceedings of the 7th International ACM SIGPLAN Conference on Principles and Practice of Declarative Programming, July 11-13 2005, Lisbon, Portugal. Edited by Pedro Barahona and Amy P. Felty. ACM, 2005, pages 82–93. doi: 10.1145/ 1069774.1069782. [42] Leo A. Meyerovich, Arjun Guha, Jacob P. Baskin, Gregory H. Cooper, Michael Greenberg, Aleks Bromfield, and Shriram Krishnamurthi. “Flapjax: a programming language for Ajax applications”. In: Proceedings of the 24th Annual ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications, OOPSLA 2009, October 25-29, 2009, Orlando, Florida, USA. Edited by Shail Arora and Gary T. Leavens. ACM, 2009, pages 1–20. doi: 10.1145/ 1640089.1640091. [43] Yaron Minsky. Introducing Incremental. Jane Street Tech Blog. July 2015. url: https://blog.janestreet.com/introducing-incremental/ (visited on 2019-05). [44] Koko Muroya, Steven W. T. Cheung, and Dan R. Ghica. “The Geometry of Computation-Graph Abstraction”. In: Proceedings of the 33rd Annual ACM/IEEE Symposium on Logic in Computer Science, LICS 2018, Oxford, UK, July 09-12, 2018. Edited by Anuj Dawar and Erich Grädel. ACM, 2018, pages 749–758. doi: 10.1145/3209108.3209127. [45] Koko Muroya and Dan R. Ghica. “The Dynamic Geometry of Interaction Ma- chine: A Call-by-Need Graph Rewriter”. In: 26th EACSL Annual Conference on Computer Science Logic, CSL 2017, August 20-24, 2017, Stockholm, Sweden. 2017, 32:1–32:15. doi: 10.4230/LIPIcs.CSL.2017.32. [46] Koko Muroya and Dan R. Ghica. “The Dynamic Geometry of Interaction Ma- chine: A Token-Guided Graph Rewriter”. In: Logical Methods in Computer Science 15.4 (2019). url: https://lmcs.episciences.org/5882. [47] Henrik Nilsson, Antony Courtney, and John Peterson. “Functional Reactive Programming, Continued”. In: Proceedings of the 2002 ACM SIGPLAN Workshop on Haskell. Haskell ’02. Pittsburgh, Pennsylvania: Association for Computing Machinery, 2002, pages 51–64. isbn: 1-58113-605-6. doi: 10.1145/581690.581695. [48] Gordon D. Plotkin. “LCF Considered as a Programming Language”. In: Electronic Notes in Theoretical Computer Science 5.3 (1977), pages 223–255. doi: 10.1016/ 0304-3975(77)90044-5. [49] William Pugh and Tim Teitelbaum. “Incremental Computation via Function Caching”. In: Conference Record of the Sixteenth Annual ACM Symposium on Principles of Programming Languages, Austin, Texas, USA, January 11-13, 1989. ACM Press, 1989, pages 315–328. doi: 10.1145/75277.75305.

12:29 Transparent Synchronous Dataflow

[50] G. Ramalingam and Thomas W. Reps. “A Categorized Bibliography on Incremen- tal Computation”. In: Conference Record of the Twentieth Annual ACM SIGPLAN- SIGACT Symposium on Principles of Programming Languages, Charleston, South Carolina, USA, January 1993. Edited by Mary S. Van Deusen and Bernard Lang. ACM Press, 1993, pages 502–510. doi: 10.1145/158511.158710. [51] Boaz Ronen, Michael A. Palley, and Henry C. Lucas Jr. “Spreadsheet Analysis and Design”. In: Communications of the ACM 32.1 (1989), pages 84–93. doi: 10.1145/63238.63244. [52] Guido Salvaneschi, Gerold Hintz, and Mira Mezini. “REScala: bridging between object-oriented and functional style in reactive applications”. In: 13th International Conference on Modularity, MODULARITY ’14, Lugano, Switzerland, April 22-26, 2014. Edited by Walter Binder, Erik Ernst, Achille Peternier, and Robert Hirschfeld. ACM, 2014, pages 25–36. doi: 10.1145/2577080.2577083. [53] William W. Wadge and Edward A. Ashcroft. LUCID, the Dataflow Programming Language. USA: Academic Press Professional, Inc., 1985. isbn: 0-12-729650-6. [54] Zhanyong Wan and Paul Hudak. “Functional reactive programming from first principles”. In: Proceedings of the 2000 ACM SIGPLAN Conference on Program- ming Language Design and Implementation (PLDI), Vancouver, Britith Columbia, Canada, June 18-21, 2000. Edited by Monica S. Lam. ACM, 2000, pages 242–252. doi: 10.1145/349299.349331.

A Program comparison with Lucid Synchrone and Zélus

Lets consider the example we give in the introduction, the sum of an alternating signal. The example written in TSD is shown below: 1 let alt = 2 let state = ref 1 in 3 link state (1 - deref state); deref state 4 in 5 6 let sum = λinp. 7 let state = ref 0 in 8 link state (inp + deref state); deref state 9 in 10 11 let alt_sum = sum alt in ...

The Zélus implementation is remarkably similar: 1 let trans (s, i) = 1 - s 2 let node alt () = state where 3 rec state = 1 -> trans ((pre state), 0) 4 5 let plus (x, y) = x + y 6 let node sum inp = state where 7 rec state = 0 -> plus ((pre state), inp)

12:30 Steven W.T. Cheung, Dan R. Ghica, and Koko Muroya

8 9 let node alt_sum () = sum (alt ()) 10 let node main () = alt_sum ()

The key distinction is the Zélus definition of the feedback loop via recursion, versus the TSD definition in which the same loop is created via assignment. Also,TSD dataflow graphs are productive by construction, since cyclic links can only becon- structed via cells. So productivity checks are not necessary.

B Sieve of Eratosthenes in Lucid Synchrone

1 let node first x = v 2 where rec v = x fby v 3 4 let rec node sieve x = 5 let clock filter = (x mod (first x))<> 0 6 in merge filter 7 (sieve (x when filter)) 8 (true fby false) 9 10 let node from n = o where rec o = n fby (o + 1) 11 12 let clock sieve = sieve (from 2) 13 14 let node primes () = (from 2) when sieve

C Implementation

The cell is implemented as a reference storing the current value and a thunk representing the dataflow graph. The graph type corresponds to a term in the TSD calculus and can either be a dependency Thunk, or a Cell. There is also a special if-then-else graph IF_Thunk, as the behaviour of branching terms is different in the dataflow graph (both branches are evaluated). The lift function embeds any standard OCaml term into a graph term. Functions peek, step, link, assign, root work as described earlier. Notice that the deref operation is not implemented in order to keep the syntax succinct. As a result, the difference between a cell and a non-cell graph is not known incompile time which could leads to runtime error when one trying to use link on these graphs. Internally, the dataflow graph is maintained using a heterogeneous list of all cells. The Obj module is used to overcome OCaml’s type restrictions. However, the internal details are inaccessible to the programmer, who may use the module only via the PPX extension [%dfg t] which translates a pure dataflow term t into a graph. By pure dataflow, we mean that t doxes not contain ref, link, assign, root, peek nor step. These functions are not translated and should be used outside the [%dfg t] tag. The translation (ð ñV ) is indexed by a set V of variables bounded in the [%dfg t] tag: − 1 ðxñV = x (if x / V ) ∈

12:31 Transparent Synchronous Dataflow

2 ðxñV = Thunk (fun() -> x)} (if x V ) ∈ 3 ðcñV = Thunk (fun() -> c) 4 ðλx.tñV = Thunk (fun() -> fun x -> peek (ðtñV x )) ∪{ } 5 ðt uñV = apply ðtñV ðuñV 6 ðif t1 then t2 else t3ñV = ite t1 (fun() -> ðt2ñV )(fun() -> ðt3ñV ) The main helper functions are: apply simulates the application in the TSD calculus, ite implements the semi-strict behaviour of branching, Their implementations are: 1 let apply t u = Thunk (fun () -> (peek t) (peek u)) 2 let ite b t1 t2 = 3 let t1 = t1() in let t2 = t2() in 4 IF_Thunk (fun () -> if peek b then t1 else t2)

The incremental implementation is similar, except that a graph structure is maintained throughout the execution. Incrementalisation is accomplished by marking certain cells as dirty and only these cells are recomputed in a step.

C.1 Benchmarks

We tested two versions of the code, with and without incrementalisation. The latter is an optimisation in which not all cells are refreshed, but only those that need to. We ran similar (as similar as possible) versions of the same program against Reactive ML, JS Incremental, and Zélus. We chose the programs from the documentations of those programming languages, presumably as representative of their strengths. The examples were: 1. the alternating-sum automata of the introduction, 2. a large cellular automaton, 3. a long-and-thin chain of propagations, 4. a short-and-wide chain of propagations, 5. finite and infinite input response filters, 6. fold-like computations, 7. a simulation of a heating element, 8. a light controller, 9. a map-like computation, 10. a page-rank algorithm, 11. a pendulum simulation, 12. an n-body gravitational simulation, 13. and a tree propagation. For each example we could vary the size of the graph for up to 107 nodes. The benchmark tables are in the Appendix (appendix C.1). RML: As a low-level language with its own compilers we expected RML to be much faster. However, for most examples at least one of the TSD implementations had

12:32 Steven W.T. Cheung, Dan R. Ghica, and Koko Muroya

better or similar performance. RML only outperformed both TSD versions for infinite input response filter and map. Incremental JS: This is a highly-tuned OCaml library used in production by JaneStreet. It does not support cyclic dependencies so most examples could not be implemented in it. For long-and-thin and tree-like chains of propagations incremental TSD outperformed, and for short-and-wide chains plain TSD outperformed. Zélus: For the heater simulation and the light controller TSD was heavily outperformed it. For the pendulum simulation Zélus was slightly faster in very large systems. The first column represents the size of the dataflow graph. All times expressed in milliseconds.

D Type Soundness Proof

D.1 Conventions

In the following sections we will denote certain graph compositions by the rules below which are borrowed from string diagrams.

Composition For any graph G : Λ (Γ Ψ) and any graph E : (Γ Π) Ω, the → ∪ ∪ → resulting composite graph is denoted by EG : (Λ Π) (Ψ Ω). ∪ → ∪ Parallel composition For any graph G : Λ Γ and any graph E : Π Ω, the resulting → → parallel composite graph is denoted by E G : (Λ Π) (Γ Ω). ⊗ ∪ → ∪ D.2 Environments

In this section, we identify a special form of graphs, dataflow environments, which corresponds to dataflow graph model. We also prove termination for these graphs in Sec. D.5.

Definition D.1 (Boxes). There is only one kind of box, the !-box shown below:

Definition D.2 (Value dags). A value dag is a directed acyclic graph of !-boxes and C-nodes.

Definition D.3 (Term graphs). A term graph is a graph that does not have any n - nodes. { }

12:33 Transparent Synchronous Dataflow

Table 4 Benchmarks against RML and Zélus

(a) alternating-sum automata (b) heater simulation

size TSD inc. TSD RML Zélus size TSD inc. TSD Zélus 105 14 15 33 38 104 1 1 28 106 136 146 306 92 105 1 2 49 107 835 1463 2786 776 106 2 1 234

size TSD inc. TSD RML Zélus size TSD inc. TSD Zélus 105 12 14 71 30 105 85 191 88 106 140 138 705 89 106 861 1887 638 107 1301 1292 6466 648 107 8793 21 221 6464

(e) cellular automata (f) planets

size TSD inc. TSD RML size TSD inc. TSD RML 2 10 2 2 8 10 6 6 7 3 10 4 4 897 102 323 336 597 4 10 74 88 1601 103 46 644 47 698 54 268

(g) FIR filter (h) IIR filter

size TSD inc. TSD RML size TSD inc. TSD RML 2 10 32 226 32 10 116 431 67 3 10 381 3905 272 102 1243 8351 468 4 10 11630 46323 7728 103 17 765 198 376 6465

(i) page rank (j) map

size TSD inc. TSD RML size TSD inc. TSD RML 10 1 1 2 103 2 1 2 102 10 2 11 104 34 14 2 103 2970 387 3060 105 462 188 23

(k) fold-max (l) fold-max 2

size TSD inc. TSD RML size TSD inc. TSD RML 102 1 2 2 102 1 2 2 103 170 2 1 103 2 2 2 104 5381 32 2 104 13 26 2

(m) fold-sum (n) fold-sum 2

size TSD inc. TSD RML size TSD inc. TSD RML 102 2 2 2 102 2 1 2 103 141 5 1 103 2 2 2 104 52 868 51 2 104 10 26 2

12:34 Steven W.T. Cheung, Dan R. Ghica, and Koko Muroya

Table 5 Benchmarks against JS incremental

(a) chain of propagation (b) tree propagation

size inc. TSD JS Incr. size TSD inc. TSD JS Incr. 3 10 3 5 103 2 2 5 4 10 11 15 104 13 2 7 5 10 167 52 105 121 5 15 6 10 1796 733 106 1629 28 100 7 10 2243 8222 107 15 510 275 998

size TSD inc. TSD JS Incr. 103 2 1 7 104 8 3 7 105 152 12 20 106 1683 48 132 107 17 217 384 1172

Definition D.4 (Dataflow environment). A dataflow environment is the largest graph connecting (in both direction) to all n -node and consisting of only $, if, C, d -nodes satisfying the following conditions: { } { } 1. the out-port of any C-node is not connected to a C-node nor a !-box, and 2. the left out-port of any if-node is not connected to a !-box, and 3. at least one of the out-ports of any $-nodes is not connected to a !-box.

D.3 Query and Answer

Definition D.5 (Answer sets). We define the answer sets any e : θ as follows:

Anse:Int = (n, ) { − } Anse:Cell = (n, e) ¨{ } (n, g) if e is connected to a dataflow environment Anse:!Int = { } (n, ) otherwise { − } Anse:Unit = Anse:!Unit = ((), ) { − } Ans Ans λ, e:κ1¨κ2 = e:!(κ1¨κ2) = ( ) { − } Definition D.6 (Terminating graphs). For any graph G : Λ and any port e : κ → ; ∈ dom(Λ), (G, e) iff there exists some G0 such that Init(G, e) ∗ Final(G0, e, X ) for some ⇓ 7→ X Anse. ∈ Lemma D.1 (Stack extension over transitions). For any transitions

(G, (e, d, f , S, B), ) (G0, (e0, d0, f 0, S0, B0), ), ; 7→ ;

12:35 Transparent Synchronous Dataflow

we also have for any Se, Be,

(G, (e, d, f , SSe, BBe), ) (G0, (e0, d0, f 0, S0Se, B0Be), ) ; 7→ ; Proof. This is proved by case analysis on all transitions.

Corollary D.1.1 (Termination extending over stacks). For any graph G : Λ and → ; any port e : κ dom(Λ) inside G, if (G, (e, d, f , S, B), ) ∗ (G0, (e0, d0, f 0, S0, B0), ) then ∈ ; 7→ ; for any Se, Be we also have (G, (e, d, f , SSe, BBe), ) ∗ (G0, (e0, d0, f 0, S0Se, B0Be), ) ; 7→ ; D.4 Valid States

Definition D.7 (Paths). A path is an ordered list of ports e0...en such that if ei, ei+1 is the incoming and the outgoing port of same node.

Definition D.8 (Reachability). A node X is reachable from a port e if there exists a path from e to the incoming port of X .

Definition D.9 (Evaluated in-ports). An in-port is evaluated if its reachable graph K is an environment.

Definition D.10 (Circular requirements). A graph G satisfies the circular requirements if all its circular paths satisfy one of the following conditions: 1. the path includes the right and left outgoing port of a λ/µ-node and all the ports and nodes in this path are only reachable through the respective λ/µ-node, 2. the path includes a n -node. { } Definition D.11 (Valid graphs). A graph G is valid if it satisfies all the following conditions: 1. any !-nodes, ?-nodes, λ-nodes and µ-nodes must only appear in the form of boxes, 2. the left out-port of a λ-node or a µ-node must either be connected by a C-node without any in-port or be reachable from its right out-port, 3. the out-port of any C-node or ?-node must be evaluated or to a ?/C-node or the left-in-port of a λ-node or a µ-node, 4. the out-port of any n -node must be evaluated, and { } 5. it satisfies the circular requirements.

Definition D.12 (Valid positions). For any graph G, a token δ = (e, d, f , S, B) is said to have a valid position if it satisfies all the following conditions: 1. if e is inside a !-box, it must be the out-port of the !-node which has no outer boxes, and 2. e is not the in-port nor out-port of any ?-node.

Definition D.13 (Valid rewrite flags). For any graph G, a token δ = (e, d, f , S, B) is said to have a valid rewrite flag if it satisfies one of the following conditions: 1. if f = @ then e must be the in-port of an @-node and d = , ↑ 2. if f = if then e must be the middle/right out-port of an if-node and d = , ↑

12:36 Steven W.T. Cheung, Dan R. Ghica, and Koko Muroya

3. if f !, C then e must be the out-port of the respective node and d = , ∈ { } ↑ 4. if f = µ then e must be the in-port of a µ-node and d = , ↑ 5. if f m, p, r(i), l(i), a(b, i) then e must be the in-port of the respective node and ∈ { } d = , ↓ 6. if f sp, s then e must be the in-port of an s-node with d = or d = respectively, ∈ { } ↑ ↓ 7. f = .

Definition D.14 (Valid stacks). For any graph G and any path e0 ... en, an eval token δ = (en, d, f , S, B) is said to have valid stacks relative to p if textvalid P’ d S B = true where P’ is the reverse of P and isValid is defined as follows: 1 isValid :: Path -> Direction -> C-stack -> B-stack -> Boolean 2 isValid p (? : S) B = validHist p S B e↑ Ans e 3 isValid ( n : p) (X : S) B = X en and validHist ( n : p) S B 4 isValid _ _ _ _ =↓ false ∈ 5 6 validHist :: Path -> C-stack -> B-stack -> Boolean 7 validHist [] [] [] = true 8 validHist [] _ _ = false 9 validHist (ei : p) S B = 10 if ei is the left-output of a #-node then 11 S == X : S' and X Anse and validHist p S' B ∈ 0 12 where e0 is the right-output of the #-node 13 else if ei is the middle-output of an if-node and i < n then 14 (S == if0 : S' or S == if1 : S') and validHist p S' B 15 else if ei is the right-output of an if-node and i < n then 16 S == X : S' and X Anse and validHist p S' B ∈ 0 17 where e0 is the middle-output of the if-node 18 else if ei is the output of a C-node then 19 B == ei 1 : B' and validHist p S B' 20 else − 21 validHist p S B

Definition D.15 (Valid graphs relative to paths). For any graph G, any path p = e0...en and token (en, d, f , X : S, B), G is valid relative to p if it satisfies the following conditions: 1. if en is the out-port of a !-node, d = and f = then this !-node cannot be connected by a C-node, ↑

2. if en is the in-port or out-port of a !-node and d = then this !-node cannot be connected by a C-node, ↓ 3. there cannot be two consecutive ports in p being the out-port of a C-node except when d = , f = C and en is the out-port of a C-node, ↑ 4. en must not be only reachable by an λ-node or a µ-node (that is not inside a box) from its right out-port nor its left in-port,

5. if d = then X = (n, g) if and only if en is connected to a dataflow environment. ↓ Definition D.16 (Valid tokens). For any graph G, any path p = e0...en, a token (en, d, f , S, B) is valid relative to p if it has a valid position, a valid rewrite flag, valid stacks relative to p and G is valid relative to p.

12:37 Transparent Synchronous Dataflow

Definition D.17 (Valid prop-tokens). A state π = (G, (e, d, f , S, B), P) has valid prop- tokens if it satisfies all the following conditions: 1. P can only be non-empty when f = sp, 2. every token in P must all be valid relative to a unique non-circular path starting from a n -node. { } Definition D.18 (Evaluated requirements). For any graph G, an eval token δ = (e, d, f , S, B) satisfies the evaluated requirements if it satisfies the following conditions: 1. if d = , f = and e : κ then e is evaluated, ↓ 2. if e is reachable by an if-node from the middle-out-port or the right-out-port, then its left-out-port must be evaluated, 3. if e is reachable by an if-node from the right-out-port and f = , then its middle- out-port must be evaluated, 4. if d = and e is the in-port of an ω-node (unary operations) then its out-port must be evaluated,↓ 5. if e is reachable by an #-node (binary operations) or an @-node from the left-out- port, then its right-out-port must be evaluated, 6. if d = and e is the in-port of a #-node then all its out-ports are evaluated, and ↓ 7. if e is the in-port of an @-node and f = @ then all its out-ports are evaluated.

Definition D.19 (Valid states). A state π = (G, δ, P) is valid if G is valid, δ is valid relative to a non-circular path starting from an in-port of G, P is valid and it satisfies the evaluated requirements.

Lemma D.2 (State validity preservation). For any valid state π, if π π0 then π is also valid. 7→

Proof. This is proved by inspecting all possible transitions one-by-one.

For pass transitions and dummy rewrites, we simply needs to check if the resulting state has valid position, valid rewrite flags valid stacks and valid prop-tokens since the graph does not change. As for rewrite transitions, the trickiest part is to prove that the circular requirements holds, i.e. no arbitrary circular path exists. For example, in the λ@-rewrite, if the left-in-port of the λ-node is reachable from its right-out-port, an arbitrary circular path would be form only if its left-in-port is reachable from the right-out-port of the @-node which is impossible because all the ports in the path must be reachable through the λ-node which means this part of the graph is isolated from the right-out-port of the @-node. The other possible rewrite to create circular path is the l-rewrite. However a l-rewrite will create a circular path that has a cell in it, as such it conforms to the requirements. Other requirements are checked accordingly.

Corollary D.2.1. For any valid state π, if π π0 then π0 is also valid. 7→

12:38 Steven W.T. Cheung, Dan R. Ghica, and Koko Muroya

D.5 Termination of Dataflow Environments

Proposition D.3 (Termination of dataflow environments). For any valid dataflow environments E : Λ and any e dom(Λ), there exists some X Anse such that → ; ∈ ∈ Init(E, e) ∗ Final(E, e, X ) such that no rewrites occur. 7→ Proof. This can be proved by induction on the maximum length (n) of the path from e that stops at any n . { } Base Case (n = 0). This case is not applicable.

Base Case (n = 1). The only case here would be a single n -node which terminates. { } Inductive Step (n = k + 1). This is proved by case analysis on the possible nodes connected by e. Sub-Case e is connected to a $-node, if-node, , C-node or d-node or !-node. These cases are similar and thus we will show the proofs for $-node. Running an execution, we have:

G$, (e, , , ? : , ), G$, (e1, , , ? : , ), (1) ↑ ; 7→ ↑ ; ∗ G$, (e1, , , X : , ), (2) 7→ ↓ ; G$, (e2, , , ? : X : , ), (3) 7→ ↑ ; ∗ G$, (e2, , , Y : X : , ), (4) 7→ ↓ ; G$, (e, , $, (m, g) : , ), (5) 7→ ↓ ; G$, (e, , , (m, g) : , ), (6) 7→ ↓ ; From (1) to (2) and (3) to (4), since the whole graph is a dataflow environment, therefore the at least one of the out-port must be a dataflow environment as well. On the other hand, if the out-port is connected to a constant !-box then it obviously comes back, there fore we apply the induction hypothesis on the remaining graph and Cor. D.1.1. From (4) to (5) by the definition of dataflow environment, one of the out-port must not be connected to a !-box, as such by validity, one of Y, X must be in the form of (m, g).

D.6 Determinism

In this section we proved that propagation always terminates and produce unique results and hence the transitions are deterministic up to equivalence of propagation sequences. The intuition is that all the n -nodes are connected to a dataflow environment therefore as we have proved{ before} that dataflow environment always terminates and produces the same graph, thus propagation will also terminate.

Lemma D.4 (Termination of prop tokens). For any valid state (G, (r, , sp, S, B), [e, , ? : ↑ ↑ , ]) where r is the in-port of an s-node, and e : κ of a n -node, there exists a sequence { } of transitions (G, (r, , sp, S, B), [e, , ? : , ]) ∗ (G, (r, , sp, S, B), [e, , X : , ]). ↑ ↑ 7→ ↑ ↓

12:39 Transparent Synchronous Dataflow

Proof. Since by validity, any n -node will always be connecting to a dataflow environment. Therefore this is simply{ } a consequence of Prop. D.3.

Proposition D.5 (Termination of propagation). For any graph G, any possible sequences P P from (G, (e, , sp, S, B), Init ) will eventually reach (G, (e, , sp, S, B), Final (X~)) for some X~ where e is↑ the in-port of an s-node. ↑

Proof. This is proved by contradiction. If the sequence does not reach the final state, there are two possibilities: 1) the sequence is infinite or 2) the sequence reaches a state which is not final but cannot proceed. For the first case, at least one of sequences of a prop token is infinite which contradicts Lem. D.4. For the second case, italso means that one of the prop token is stuck which also contradicts Lem. D.4.

Lemma D.6 (Diamond property). For any valid state (G, δ, P) if (G, δ, P) (G, δ, P0) 7→ and (G, δ, P) (G, δ, P00) then there exists a valid state π such that (G, δ, P0) π and 7→ 7→ (G, δ, P00) π. 7→

Proof. Since we have (G, δ, P) (G, δ, P0) and (G, δ, P) (G, δ, P00), if the states are produced with advancing different7→ prop-tokens, i.e. 7→

(G, δ, t1..ti..t j..tn ) (G, δ, t1..ti0..t j..tn ) { } 7→ { } and

(G, δ, t1..ti..t j..tn ) (G, δ, t1..ti..t0j..tn ) { } 7→ { }

. Then we can join the two sequence into (G, δ, t1..ti0..t0j..tn ) because the transition does not cause any race conditions. { }

Proposition D.7 (Confluence of propagation). For any valid state (G, δ, P), if (G, δ, P) ∗ 7→ (G, δ, P0) and (G, δ, P) ∗ (G, δ, P00) then there exists a valid state (G, δ, K) such that 7→ (G, δ, P0) ∗ (G, δ, K) and (G, δ, P00) ∗ (G, δ, K). 7→ 7→ Proof. This is a consequence of Lem. D.6.

Corollary D.7.1. There is exactly one unique final state for any sequence from (G, δ, P). By using this corollary, all the possible propagation sequences from

P (G, (e, , sp, S, B), Init ) ↑ to

P (G, (e, , sp, S, B), Final (X~)) ↑ form an equivalence class.

Definition D.20 (Step-propagation transitions). We replace the transitions in Def. 3.5 by the following transitions respectively: 1. (G, (e, , , ? : S, B), ) (G, (e, , sp, ? : S, B), ) ↑ ; 7→ ↑ ;

12:40 Steven W.T. Cheung, Dan R. Ghica, and Koko Muroya

2. (G, (e, , sp, ? : S, B), ) (G00, (e, , , (b, ) : S, B), ) where G00 and b are obtained by executing↑ the step-propagation.; 7→ ↓ − ;

Proposition D.8 (Determinism). The machine is deterministic by replacing Def. 3.5 with Def. D.20.

Proof. This is a consequence of Prop. D.5 and Prop. D.7.

In the section below, whenever we talk about transitions, unless otherwise specifies, we always mean the replaced set of transitions. As a result the set of prop-tokens will always be empty, thus we will represent the machine state as only G, δ from now on.

D.7 Expansion of Contractions

In this section we proved that any graph G behaves the same way as expanding all its outter contractions (C-nodes that are not inside a box).

Definition D.21 (U-simulation). A relation R on states is a U-simulation if it satisfies the following conditions:

1. if π1 R π2 and a transition π1 π01 is possible then there exists two states π001 , π02 7→ such that π01 ∗ π001 (possibly no transitions), π2 π02 and π001 R π02, 7→ 7→ 2. π1 R π2 then if there is no possible transition for π1 then there is no possible transition for π2 as well,

3. if π1 R π2, then π1 is an ending state if and only if π2 is an ending state.

Lemma D.9. For any U-simulation R if π1 R π2 and π2 ∗ π02 then there exists a state 7→ π01 such that π1 ∗ π01 and π01 R π02. 7→ n Proof. This is proved by induction on the sequence π2 π02. 7→

Base Case n = 0. Then π2 = π02 and since π1 R π2 then we can pick π01 = π1 and thus it is true.

Inductive Case n = k +1. We need to show that there exists some state π01 such that π1 ∗ π01 and π01 R π02. Suppose there is no possible transition from π1 then because 7→ π1 R π2 thus there should not be any transition from π2 as well which contradicts k+1 the assumption that π2 π02, therefore there must exists a π01 such that π1 π01. 7→ 7→ As a result, because π1 R π2 there exists some π001 , π∗2 such that π01 ∗ π001 such that 7→ k π001 R π∗2. Since is deterministic (Prop. D.8) therefore we have π2 π∗2 π02. By 7→ 7→ 7→ using the induction hypothesis, there must exists some π∗1 such that π001 ∗ π∗1 and 7→ π∗1 R π02.

+ Lemma D.10. For any U-simulation R if π1 R π2 and π2 ∗ π02 then there exists a + 7→ state π01 such that π1 ∗ π01 and π01 R π02. 7→ n Proof. This proved by induction on n 1 for π1 R π2. ≥

12:41 Transparent Synchronous Dataflow

Base Case n = 1. This is proved in Lem. D.9.

k Inductive Case n = k + 1. We need to show that if π1 R π2 R π3 and π3 ∗ π03 + 7→ then there exists some π01 such that π1 ∗ π01 and π1 R π01. Since π2 R π3 by using 7→ + Lem. D.9, there exists some π02 such that π2 ∗ π02 and π02 R π03. Now by using 7→ the induction hypothesis on k, there must exists some π01 such that π1 ∗ π01 and + + 7→ π01 R π02. Thus we have π01 R π03. Lemma D.11. For any U-simulation R its transitive closure R+ is also a U-simulation.

Proof. We need to show that R+ satisfies the three conditions of a U-simulation.

+ Case (1). We need to show that if π1 R πe and a transition π1 π01 is possible 7→ + then there exists two states π001 , π0e such that π01 ∗ π001 , πe π0e and π001 R π0e. 7→n 7→ Since there must exists a n 1 such that π1 R πe, therefore we can do induction ≥ on n. When n = 1 it is trivially true because π1 R πe. When n = k + 1 then we have k k π1 R π2 R πe. Since π1 R π2 and π1 π01 is possible therefore by using the induction 7→ + hypothesis, there exists two states π001 , π02 such that π01 ∗ π001 , π2 π02 and π001 R π02. 7→ 7→ Since π2 R πe and π2 π02, therefore these also exists two states π002 and π0e such that 7→ π02 ∗ π002 , πe π0e and π002 R π0e. Then by using Lem. D.10, there must exists some 7→ 7→ + state π0001 such that π001 ∗ π0001 and π0001 R π002 . Thus π0001 R π0e. 7→ + Case (2). We need to show that if π1 R πe and there is no possible transition from π1 then so is πe. Since there must exists a n 1 such that ≥

π1 R π2 R ... R πn 1 R πe − therefore we can do induction on n. When n = 1 we have π1 R πe and thus πe has no possible transition. When n = k + 1 we have π1 R π2 R ... R πk R πe. Since π1 R π2 means that π2 has no possible transitions and hence by the induction hypothesis this is true.

+ Case (3). We need to show that if π1 R πe then π0 is an ending state if and only if πe is an ending state. Since there must exists a n 1 such that ≥

π1 R π2 R ... R πn 1 R πe −

, therefore we can do induction on n. When n = 1 it is trivially true because π1 R πe. When n = k + 1 we have π1 R π2 R ... R πk R πe. a) π1 is an ending state implies πe is an ending state: Since π1 R π2 means that π2 is also an ending state therefore by the induction hypothesis, πe is also an ending state. The other direction is similar.

Lemma D.12. For any states π1, π2 and an U-simulation R such that π1 R π2, then e e e e π1 ∗ π1 π2 ∗ π2 for some ending states π1, π2. 7→ ⇐⇒ 7→

12:42 Steven W.T. Cheung, Dan R. Ghica, and Koko Muroya

e e Proof. For the direction π1 ∗ π1 = π2 ∗ π2, it can be proved by induction on 7→n e ⇒ 7→ the number of sequence π1 π1. 7→ e Base Case n = 0. Since π1 = π1 and π1 R π2, therefore π2 is an ending state.

k+1 e Inductive Step n = k + 1. We need to show that if π1 π1 then there must e e 7→ exists an ending state π2 such that π2 ∗ π2. 7→ k e We can factorise the sequence into π1 π01 π1. By the definition of U-simulation, 7→ 7→ there must exists two states π001 and π02 such that π01 ∗ π001 , π2 π02 and π001 R π02. 7→ 7→ Therefore by determinism, either 1) π001 is an ending state which then by definition π02 i e has to be an ending state or 2) π001 π1 where i k and thus by induction hypothesis, e 7→ ≤ e there must exists some state π2 such that π02 ∗ π2. 7→ e e For the other direction π1 ∗ π1 = π2 ∗ π2, it is proved in Lem. D.9. 7→ ⇐ 7→ Definition D.22 (Replacement of contractions). We define a relation (replace by) ≺ on graphs where = m c i ≺ ≺ ∪ ≺ ∪ ≺

CfAAAB8nicbVDLSgMxFL1TX7W+qi7dBIvgqsxUQZeFblxWsA9oh5JJM21oJjMkd8Qy9DPcuFDErV/jzr8xbWehrQcCh3PuIfeeIJHCoOt+O4WNza3tneJuaW//4PCofHzSNnGqGW+xWMa6G1DDpVC8hQIl7yaa0yiQvBNMGnO/88i1EbF6wGnC/YiOlAgFo2ilXh/5k01ljXA2KFfcqrsAWSdeTiqQozkof/WHMUsjrpBJakzPcxP0M6pRMMlnpX5qeELZhI54z1JFI278bLHyjFxYZUjCWNunkCzU34mMRsZMo8BORhTHZtWbi/95vRTDWz8TKkmRK7b8KEwlwZjM7ydDoTlDObWEMi3sroSNqaYMbUslW4K3evI6adeq3lW1dn9dqZO8jiKcwTlcggc3UIc7aEILGMTwDK/w5qDz4rw7H8vRgpNnTuEPnM8fsTGRaQ==

AAAB6HicbVBNS8NAEJ3Ur1q/qh69LBbBU0mqoDcLXjy2YGuhDWWznbRrN5uwuxFK6C/w4kERr/4kb/4bt20O2vpg4PHeDDPzgkRwbVz32ymsrW9sbhW3Szu7e/sH5cOjto5TxbDFYhGrTkA1Ci6xZbgR2EkU0igQ+BCMb2f+wxMqzWN5byYJ+hEdSh5yRo2Vmjf9csWtunOQVeLlpAI5Gv3yV28QszRCaZigWnc9NzF+RpXhTOC01Es1JpSN6RC7lkoaofaz+aFTcmaVAQljZUsaMld/T2Q00noSBbYzomakl72Z+J/XTU147WdcJqlByRaLwlQQE5PZ12TAFTIjJpZQpri9lbARVZQZm03JhuAtv7xK2rWqd1GtNS8rdZLHUYQTOIVz8OAK6nAHDWgBA4RneIU359F5cd6dj0VrwclnjuEPnM8fhumMpQ== ? AAAB6HicbVBNS8NAEJ3Ur1q/qh69LBbBU0mqoDcLXjy2YGuhDWWznbRrN5uwuxFK6C/w4kERr/4kb/4bt20O2vpg4PHeDDPzgkRwbVz32ymsrW9sbhW3Szu7e/sH5cOjto5TxbDFYhGrTkA1Ci6xZbgR2EkU0igQ+BCMb2f+wxMqzWN5byYJ+hEdSh5yRo2Vmjf9csWtunOQVeLlpAI5Gv3yV28QszRCaZigWnc9NzF+RpXhTOC01Es1JpSN6RC7lkoaofaz+aFTcmaVAQljZUsaMld/T2Q00noSBbYzomakl72Z+J/XTU147WdcJqlByRaLwlQQE5PZ12TAFTIjJpZQpri9lbARVZQZm03JhuAtv7xK2rWqd1GtNS8rdZLHUYQTOIVz8OAK6nAHDWgBA4RneIU359F5cd6dj0VrwclnjuEPnM8fhumMpQ== ? m AAAB6HicbVBNS8NAEJ34WetX1aOXxSJ4KkkV9FjoxWML9gPaUDbbSbt2swm7G6GE/gIvHhTx6k/y5r9x2+agrQ8GHu/NMDMvSATXxnW/nY3Nre2d3cJecf/g8Oi4dHLa1nGqGLZYLGLVDahGwSW2DDcCu4lCGgUCO8GkPvc7T6g0j+WDmSboR3QkecgZNVZq1gelsltxFyDrxMtJGXI0BqWv/jBmaYTSMEG17nluYvyMKsOZwFmxn2pMKJvQEfYslTRC7WeLQ2fk0ipDEsbKljRkof6eyGik9TQKbGdEzVivenPxP6+XmvDOz7hMUoOSLReFqSAmJvOvyZArZEZMLaFMcXsrYWOqKDM2m6INwVt9eZ20qxXvulJt3pRrJI+jAOdwAVfgwS3U4B4a0AIGCM/wCm/Oo/PivDsfy9YNJ585gz9wPn8AjPmMqQ== C G m c AAAB6HicbVBNS8NAEJ34WetX1aOXxSJ4KkkV9FjoxWML9gPaUDbbSbt2swm7G6GE/gIvHhTx6k/y5r9x2+agrQ8GHu/NMDMvSATXxnW/nY3Nre2d3cJecf/g8Oi4dHLa1nGqGLZYLGLVDahGwSW2DDcCu4lCGgUCO8GkPvc7T6g0j+WDmSboR3QkecgZNVZq1gelsltxFyDrxMtJGXI0BqWv/jBmaYTSMEG17nluYvyMKsOZwFmxn2pMKJvQEfYslTRC7WeLQ2fk0ipDEsbKljRkof6eyGik9TQKbGdEzVivenPxP6+XmvDOz7hMUoOSLReFqSAmJvOvyZArZEZMLaFMcXsrYWOqKDM2m6INwVt9eZ20qxXvulJt3pRrJI+jAOdwAVfgwS3U4B4a0AIGCM/wCm/Oo/PivDsfy9YNJ585gz9wPn8AjPmMqQ== C ≺ l h ≺ G … G l AAAB6HicbVBNS8NAEJ3Ur1q/qh69rBbBU0mqoMeCF48t2FpoQ9lsJ+3azSbsboQS+gu8eFDEqz/Jm//GbZuDtj4YeLw3w8y8IBFcG9f9dgpr6xubW8Xt0s7u3v5B+fCoreNUMWyxWMSqE1CNgktsGW4EdhKFNAoEPgTj25n/8IRK81jem0mCfkSHkoecUWOl5mm/XHGr7hxklXg5qUCORr/81RvELI1QGiao1l3PTYyfUWU4Ezgt9VKNCWVjOsSupZJGqP1sfuiUnFtlQMJY2ZKGzNXfExmNtJ5Ege2MqBnpZW8m/ud1UxPe+BmXSWpQssWiMBXExGT2NRlwhcyIiSWUKW5vJWxEFWXGZlOyIXjLL6+Sdq3qXVZrzatKneRxFOEEzuACPLiGOtxBA1rAAOEZXuHNeXRenHfnY9FacPKZY/gD5/MHWXGMhw== ! h

m AAAB6HicbVBNS8NAEJ3Ur1q/qh69rBbBU0mqoMeCF48t2FpoQ9lsJ+3azSbsboQS+gu8eFDEqz/Jm//GbZuDtj4YeLw3w8y8IBFcG9f9dgpr6xubW8Xt0s7u3v5B+fCoreNUMWyxWMSqE1CNgktsGW4EdhKFNAoEPgTj25n/8IRK81jem0mCfkSHkoecUWOl5mm/XHGr7hxklXg5qUCORr/81RvELI1QGiao1l3PTYyfUWU4Ezgt9VKNCWVjOsSupZJGqP1sfuiUnFtlQMJY2ZKGzNXfExmNtJ5Ege2MqBnpZW8m/ud1UxPe+BmXSWpQssWiMBXExGT2NRlwhcyIiSWUKW5vJWxEFWXGZlOyIXjLL6+Sdq3qXVZrzatKneRxFOEEzuACPLiGOtxBA1rAAOEZXuHNeXRenHfnY9FacPKZY/gD5/MHWXGMhw== ! AAAB6HicbVBNS8NAEJ3Ur1q/qh69rBbBU0mqoMeCF48t2FpoQ9lsJ+3azSbsboQS+gu8eFDEqz/Jm//GbZuDtj4YeLw3w8y8IBFcG9f9dgpr6xubW8Xt0s7u3v5B+fCoreNUMWyxWMSqE1CNgktsGW4EdhKFNAoEPgTj25n/8IRK81jem0mCfkSHkoecUWOl5mm/XHGr7hxklXg5qUCORr/81RvELI1QGiao1l3PTYyfUWU4Ezgt9VKNCWVjOsSupZJGqP1sfuiUnFtlQMJY2ZKGzNXfExmNtJ5Ege2MqBnpZW8m/ud1UxPe+BmXSWpQssWiMBXExGT2NRlwhcyIiSWUKW5vJWxEFWXGZlOyIXjLL6+Sdq3qXVZrzatKneRxFOEEzuACPLiGOtxBA1rAAOEZXuHNeXRenHfnY9FacPKZY/gD5/MHWXGMhw== ! AAAB6HicbVBNS8NAEJ34WetX1aOXxSJ4KkkV9FjoxWML9gPaUDbbSbt2swm7G6GE/gIvHhTx6k/y5r9x2+agrQ8GHu/NMDMvSATXxnW/nY3Nre2d3cJecf/g8Oi4dHLa1nGqGLZYLGLVDahGwSW2DDcCu4lCGgUCO8GkPvc7T6g0j+WDmSboR3QkecgZNVZq1gelsltxFyDrxMtJGXI0BqWv/jBmaYTSMEG17nluYvyMKsOZwFmxn2pMKJvQEfYslTRC7WeLQ2fk0ipDEsbKljRkof6eyGik9TQKbGdEzVivenPxP6+XmvDOz7hMUoOSLReFqSAmJvOvyZArZEZMLaFMcXsrYWOqKDM2m6INwVt9eZ20qxXvulJt3pRrJI+jAOdwAVfgwS3U4B4a0AIGCM/wCm/Oo/PivDsfy9YNJ585gz9wPn8AjPmMqQ== C m

? ? G G h i ! h m ≺ ! C l where C f is the largest forest of C-nodes connected, and the C-node on the left-hand- side of c has more than one in-ports. ≺ Definition D.23. We define a binary relation ˆ on valid states such that for any graph ≺ context [], ( [G1], δ1) ˆ ( [G2], δ2) if G1 G2 where the bottom C-node is not G G ≺ G ≺ connected by another C-node, or G1 = G2, δ1 = δ2, the position of the main token is in . Note that if C f is empty, then the only in-ports for G1 would be the in-ports of theGC-node. Lemma D.13. ˆ is a U-simulation. ≺ Proof. This is proved by analysing all the possible transitions one-by-one. In some of the following cases, we will only show the part of the graph that matters. Case when token is inside G excluding the border. If it is a pass transition or a dummy rewrite, then we also have the exact same transition on the right-hand-side.

12:43 Transparent Synchronous Dataflow

If it is a rewrite transition then it depends on whether it involves any of the holes. If not then it is trivial. If yes, then it must be one of the following cases (other cases are disproved by validity): (1)

G h

G G h , h, , !, S, B ( AAAB6HicbVBNS8NAEJ3Ur1q/qh69rBbBU0mqoMeCF48t2FpoQ9lsJ+3azSbsboQS+gu8eFDEqz/Jm//GbZuDtj4YeLw3w8y8IBFcG9f9dgpr6xubW8Xt0s7u3v5B+fCoreNUMWyxWMSqE1CNgktsGW4EdhKFNAoEPgTj25n/8IRK81jem0mCfkSHkoecUWOl5mm/XHGr7hxklXg5qUCORr/81RvELI1QGiao1l3PTYyfUWU4Ezgt9VKNCWVjOsSupZJGqP1sfuiUnFtlQMJY2ZKGzNXfExmNtJ5Ege2MqBnpZW8m/ud1UxPe+BmXSWpQssWiMBXExGT2NRlwhcyIiSWUKW5vJWxEFWXGZlOyIXjLL6+Sdq3qXVZrzatKneRxFOEEzuACPLiGOtxBA1rAAOEZXuHNeXRenHfnY9FacPKZY/gD5/MHWXGMhw== ! AAAB6HicbVBNS8NAEJ3Ur1q/qh69rBbBU0mqoMeCF48t2FpoQ9lsJ+3azSbsboQS+gu8eFDEqz/Jm//GbZuDtj4YeLw3w8y8IBFcG9f9dgpr6xubW8Xt0s7u3v5B+fCoreNUMWyxWMSqE1CNgktsGW4EdhKFNAoEPgTj25n/8IRK81jem0mCfkSHkoecUWOl5mm/XHGr7hxklXg5qUCORr/81RvELI1QGiao1l3PTYyfUWU4Ezgt9VKNCWVjOsSupZJGqP1sfuiUnFtlQMJY2ZKGzNXfExmNtJ5Ege2MqBnpZW8m/ud1UxPe+BmXSWpQssWiMBXExGT2NRlwhcyIiSWUKW5vJWxEFWXGZlOyIXjLL6+Sdq3qXVZrzatKneRxFOEEzuACPLiGOtxBA1rAAOEZXuHNeXRenHfnY9FacPKZY/gD5/MHWXGMhw== ! )

G h

kAAAB6HicbVBNS8NAEJ3Ur1q/qh69LBbBU0mqoMeCF48t2A9oQ9lsJ+3azSbsboQS+gu8eFDEqz/Jm//GbZuDtj4YeLw3w8y8IBFcG9f9dgobm1vbO8Xd0t7+weFR+fikreNUMWyxWMSqG1CNgktsGW4EdhOFNAoEdoLJ3dzvPKHSPJYPZpqgH9GR5CFn1FipORmUK27VXYCsEy8nFcjRGJS/+sOYpRFKwwTVuue5ifEzqgxnAmelfqoxoWxCR9izVNIItZ8tDp2RC6sMSRgrW9KQhfp7IqOR1tMosJ0RNWO96s3F/7xeasJbP+MySQ1KtlwUpoKYmMy/JkOukBkxtYQyxe2thI2poszYbEo2BG/15XXSrlW9q2qteV2pkzyOIpzBOVyCBzdQh3toQAsYIDzDK7w5j86L8+58LFsLTj5zCn/gfP4AyZmM0Q== l

G G h , h, , !, S, B

( AAAB6HicbVBNS8NAEJ3Ur1q/qh69rBbBU0mqoMeCF48t2FpoQ9lsJ+3azSbsboQS+gu8eFDEqz/Jm//GbZuDtj4YeLw3w8y8IBFcG9f9dgpr6xubW8Xt0s7u3v5B+fCoreNUMWyxWMSqE1CNgktsGW4EdhKFNAoEPgTj25n/8IRK81jem0mCfkSHkoecUWOl5mm/XHGr7hxklXg5qUCORr/81RvELI1QGiao1l3PTYyfUWU4Ezgt9VKNCWVjOsSupZJGqP1sfuiUnFtlQMJY2ZKGzNXfExmNtJ5Ege2MqBnpZW8m/ud1UxPe+BmXSWpQssWiMBXExGT2NRlwhcyIiSWUKW5vJWxEFWXGZlOyIXjLL6+Sdq3qXVZrzatKneRxFOEEzuACPLiGOtxBA1rAAOEZXuHNeXRenHfnY9FacPKZY/gD5/MHWXGMhw== ! AAAB6HicbVBNS8NAEJ3Ur1q/qh69rBbBU0mqoMeCF48t2FpoQ9lsJ+3azSbsboQS+gu8eFDEqz/Jm//GbZuDtj4YeLw3w8y8IBFcG9f9dgpr6xubW8Xt0s7u3v5B+fCoreNUMWyxWMSqE1CNgktsGW4EdhKFNAoEPgTj25n/8IRK81jem0mCfkSHkoecUWOl5mm/XHGr7hxklXg5qUCORr/81RvELI1QGiao1l3PTYyfUWU4Ezgt9VKNCWVjOsSupZJGqP1sfuiUnFtlQMJY2ZKGzNXfExmNtJ5Ege2MqBnpZW8m/ud1UxPe+BmXSWpQssWiMBXExGT2NRlwhcyIiSWUKW5vJWxEFWXGZlOyIXjLL6+Sdq3qXVZrzatKneRxFOEEzuACPLiGOtxBA1rAAOEZXuHNeXRenHfnY9FacPKZY/gD5/MHWXGMhw== ! )

(2) we have C[CC] vs C[C] where the token is at the top of the highest C-node. In this case by validity, the current execution path does not contain any in-ports or out-ports of from the hole. And (3) we have ?G![(C f )(?G!)C] vs ?G![C(?G~ !)]. In this case copying the upper !-box using a C-node in C f will still result in a forest of C-nodes and so it is fine.

Case when token is at the border with G1 m G2. We proved this by analysing all the possible cases. ≺ Sub-Cases when token is at an in-port with d = and f = . These cases induce rewrites in the ambient graph that do not affects↑ the hole6 and thus they have one-to-one correspondence. Sub-Case when token is at an in-port with d = and f = . Since l cannot be connected to another C-node therefore we have only↑ two cases: (1)

12:44 Steven W.T. Cheung, Dan R. Ghica, and Koko Muroya

AAAB6HicbVBNS8NAEJ3Ur1q/qh69LBbBU0mqoMeCF48t2A9oQ9lsJ+3azSbsboQS+gu8eFDEqz/Jm//GbZuDtj4YeLw3w8y8IBFcG9f9dgobm1vbO8Xd0t7+weFR+fikreNUMWyxWMSqG1CNgktsGW4EdhOFNAoEdoLJ3dzvPKHSPJYPZpqgH9GR5CFn1FipiYNyxa26C5B14uWkAjkag/JXfxizNEJpmKBa9zw3MX5GleFM4KzUTzUmlE3oCHuWShqh9rPFoTNyYZUhCWNlSxqyUH9PZDTSehoFtjOiZqxXvbn4n9dLTXjrZ1wmqUHJlovCVBATk/nXZMgVMiOmllCmuL2VsDFVlBmbTcmG4K2+vE7atap3Va01ryt1ksdRhDM4h0vw4AbqcA8NaAEDhGd4hTfn0Xlx3p2PZWvByWdO4Q+czx/AgYzL e AAAB6HicbVBNS8NAEJ34WetX1aOXxSJ4KkkV9FjoxWML9gPaUDbbSbt2swm7G6GE/gIvHhTx6k/y5r9x2+agrQ8GHu/NMDMvSATXxnW/nY3Nre2d3cJecf/g8Oi4dHLa1nGqGLZYLGLVDahGwSW2DDcCu4lCGgUCO8GkPvc7T6g0j+WDmSboR3QkecgZNVZq1gelsltxFyDrxMtJGXI0BqWv/jBmaYTSMEG17nluYvyMKsOZwFmxn2pMKJvQEfYslTRC7WeLQ2fk0ipDEsbKljRkof6eyGik9TQKbGdEzVivenPxP6+XmvDOz7hMUoOSLReFqSAmJvOvyZArZEZMLaFMcXsrYWOqKDM2m6INwVt9eZ20qxXvulJt3pRrJI+jAOdwAVfgwS3U4B4a0AIGCM/wCm/Oo/PivDsfy9YNJ585gz9wPn8AjPmMqQ== C m , l, , , S, B 4 AAAB6HicbVBNS8NAEJ34WetX1aOXxSJ4KkkV9FjoxWML9gPaUDbbSbt2swm7G6GE/gIvHhTx6k/y5r9x2+agrQ8GHu/NMDMvSATXxnW/nY3Nre2d3cJecf/g8Oi4dHLa1nGqGLZYLGLVDahGwSW2DDcCu4lCGgUCO8GkPvc7T6g0j+WDmSboR3QkecgZNVZq1gelsltxFyDrxMtJGXI0BqWv/jBmaYTSMEG17nluYvyMKsOZwFmxn2pMKJvQEfYslTRC7WeLQ2fk0ipDEsbKljRkof6eyGik9TQKbGdEzVivenPxP6+XmvDOz7hMUoOSLReFqSAmJvOvyZArZEZMLaFMcXsrYWOqKDM2m6INwVt9eZ20qxXvulJt3pRrJI+jAOdwAVfgwS3U4B4a0AIGCM/wCm/Oo/PivDsfy9YNJ585gz9wPn8AjPmMqQ== C , e, , C, S, l : B ( [ AAAB6HicbVBNS8NAEJ34WetX1aOXxSJ4KkkV9FjoxWML9gPaUDbbSbt2swm7G6GE/gIvHhTx6k/y5r9x2+agrQ8GHu/NMDMvSATXxnW/nY3Nre2d3cJecf/g8Oi4dHLa1nGqGLZYLGLVDahGwSW2DDcCu4lCGgUCO8GkPvc7T6g0j+WDmSboR3QkecgZNVZq1gelsltxFyDrxMtJGXI0BqWv/jBmaYTSMEG17nluYvyMKsOZwFmxn2pMKJvQEfYslTRC7WeLQ2fk0ipDEsbKljRkof6eyGik9TQKbGdEzVivenPxP6+XmvDOz7hMUoOSLReFqSAmJvOvyZArZEZMLaFMcXsrYWOqKDM2m6INwVt9eZ20qxXvulJt3pRrJI+jAOdwAVfgwS3U4B4a0AIGCM/wCm/Oo/PivDsfy9YNJ585gz9wPn8AjPmMqQ== C ] ) ( [ l ] ) G l ↑ 7→ G ↑ vs

( [ ], l, , , S, B) ( [ ], e, , C, S, l : B) G ↑ 7→ G ↑ and (2)

Sub-Case when token is at an in-port and d = . By validity, the only possible case is when the token is at an in-port of the upper C-node↓ that is not m and a transition takes the token away from the border to G which will be the same transition for the right-hand-side. Sub-Case when token is at an out-port and d = . It is similar to the case when ↑ token is at the in-port with d = . The possible transition would either be a rewrite of the hole or if the upper C-node↑ is connected by another C-node then it would be a rewrite of those two. It can also be the case that f = and any possible transitions will take the token back to the context.

Sub-Case when token is at an out-port and d = . By validity, B = j : B0 such that ↓ j = m, as such the token goes back to an in-port that is not from the lower C-node. 6 Case when the token is at the border of G1 c G2. We proved this by analysing all possible cases. ≺ Sub-Case when token is at an in-port and d = . We have (1) the token is at one of the in-ports of the bottom C-nodes, and (2) the↑ token is at one of the in-ports of

C f . These two cases are proved similarly as the c-cases. ≺ Sub-Case when the token is at the bottom and d = . By validity the token cannot be at one of the in-ports of the C-node, so the only case↓ is when the token is at one of the in-ports of C f . Any possible transitions will take the token back into the ambient graph and the right-hand-side will have the same transition. Sub-Case when the token is at the top. By validity, the possible cases would be that the path does not incudes the !-box nor the C-node. So it would either be a rewrites inside the C f or a transition that takes the token back to the ambient graph.

Case when token is at the border of G1 e G2. The only possible cases are when the ≺ token is at the bottom with d = and it follows the same idea as previous cases. ↑

12:45 Transparent Synchronous Dataflow

+ Proposition D.14. For any graphs H1, H2 : Λ , if H1 H2 then for any e dom(Λ), + → ; ≺ ∈ (H1, e) (H2, e) where is the transitive closure of . ⇓ ⇐⇒ ⇓ ≺ ≺ + Proof. Since Init(H1, e) ˆ Init(H2, e) therefore this is simply a consequence of Lem. D.13, Lem. D.11 and Lem. D.12.≺

D.8 Re-evaluation

Definition D.24 (Stable sequences). A sequence is stable if it does not contain any actual rewrite transitions.

Lemma D.15 (Factorisation of stable sequences). For any graph G : ( e : κ Λ) , { } ∪ → ; if we have a stable sequence Init(G, e) ∗ (G, e0, , , X : S, B) then it can be factorised 7→ ↓ into Init(G, e) ∗ (G, e0, , , ? : S, B) ∗ (G, e0, , , X : S, B). 7→ ↑ 7→ ↓ n Proof. This is proved by induction on the number of transitions Init(G, e) (G, e0, , , X : 7→ ↓ S, B).

Base Case n = 0: This is impossible since the start state must have . ↑ n Inductive Case n = k + 1: Since we have Init(G, e) (G, δ) (G, e0, , , X : S, B), this can be proved by case analysis on the last transition.7→ We will7→ show↓ the proof for

( [$], e0, , $, (n, g) : S, B) ( [$], e0, , , (n, g) : S, B) where e0 is the in-port of the $G-node. Since↓ the machine7→ isG deterministic↓ we can rewind the sequence to get

Init( [$], e) n G ( [$], el , , , (n2, x) : (n1, y) : S, B) 7→ G ↓ ( [$], e0, , $, (n, g) : S, B) 7→ G ↓

Now by using induction hypothesis, we also have that

Init( [$], e) G ∗ ( [$], er , , , (n1, ) : S, B) 7→ G ↓ − ( [$], el , , , ? : (n1, ) : S, B) 7→ G ↑ − ∗ ( [$], el , , , (n2, x) : (n1, y) : S, B) 7→ G ↓ ( [$], e0, , $, (n, g) : S, B) 7→ G ↓

12:46 Steven W.T. Cheung, Dan R. Ghica, and Koko Muroya

Continuing the process we will get

Init( [$], e) G ∗ ( [$], e0, , , ? : S, B) 7→ G ↑ ( [$], er , , , ? : S, B) 7→ G ↑ ∗ ( [$], er , , , (n1, ) : S, B) 7→ G ↓ − ( [$], el , , , ? : (n1, ) : S, B) 7→ G ↑ − ∗ ( [$], el , , , (n2, x) : (n1, y) : S, B) 7→ G ↓ ( [$], e0, , $, (n, g) : S, B) 7→ G ↓

R Lemma D.16. For any graph G : ( e : κ Λ) , if Init(G, e) ∗ (G, δ) (G0, δ0) { } ∪ → ; 7→ 7→ where the first part is stable, then we also have a stable sequence Init(G0, e) ∗ (G0, δ0). 7→ R Proof. This is proved by case analysis on every actual rewrite transitions (G, δ) 7→ (G0, δ0). Case p-rewrite, r-rewrite, m-rewrite, i f -rewrite, $-rewrite, l-rewrite, a-rewrite, @-rewrite, C-rewrite, !C-rewrites, µ-rewrite: These cases are similar and thus we will show the proof for $-rewrite. Let G = [$] where is the surround context, then we have that G G

Init( [$], e) G ∗ ( [$], e0, , $, (n, ) : S, B) 7→ G ↓ − ( [C0 (n!) C0], e0, , , (n, ) : S, B) 7→ G ⊗ ⊗ ↓ − where e0 is the in-port of the $-node. Rewinding the sequence and by using Lem. D.15, we have that

Init( [$], e) G ∗ ( [$], e0, , , ? : S, B) 7→ G ↑ ( [$], er , , , ? : S, B) 7→ G ↑ ∗ ( [$], er , , , (n1, ) : S, B) 7→ G ↓ − ( [$], el , , , ? : (n1, ) : S, B) 7→ G ↑ − ∗ ( [$], el , , , (n2, ) : (n1, ) : S, B) 7→ G ↓ − − ( [$], e0, , $, (n, ) : S, B) 7→ G ↓ − ( [C0 (n!) C0], e0, , , (n, ) : S, B) 7→ G ⊗ ⊗ ↓ −

12:47 Transparent Synchronous Dataflow

where er , el are the right-out-port and left-out-port of the $-node. Since replacing the $-subgraph with a constant !-box does not affect the first part of the sequence, therefore we can construct the following sequence

Init( [C0 (n!) C0], e) G ⊗ ⊗ ∗ ( [C0 (n!) C0], e0, , , ? : S, B) 7→ G ⊗ ⊗ ↑ ( [C0 (n!) C0], e00, , , ? : S, B) 7→ G ⊗ ⊗ ↑ ( [C0 (n!) C0], e00, , , (n, ) : S, B) 7→ G ⊗ ⊗ ↓ − ( [C0 (n!) C0], e0, , , (n, ) : S, B) 7→ G ⊗ ⊗ ↓ − where e00 is the in-port to the n-node. Case P -rewrite: The proof is similar. We first have that 7→ P Init( [s], e) ∗ ( [s], e0, , sp, ? : S, B) (G0, e0, , , (b, ) : S, B) G 7→ G ↑ 7→ ↓ − then we want to construct a sequence

Init(G0, e) ∗ (G0, e0, , sp, ? : S, B) ∗ (G0, e0, , , (b, ) : S, B) 7→ ↑ 7→ ↓ − , suppose the first half of the second sequence does not lead to G0 which means that there exists some rewrite transitions. However since the difference between G and G0 is that the content of some cells are changed. This would mean that this transitions will also happen in the original sequence which draws a contradiction.

Proposition D.17. For any graph G : e : κ Λ , if Init(G, e) ∗ (G0, δ) for some { } ∪ → ; 7→ G0, δ, then we also have that Init(G0, e) ∗ (G0, δ). 7→ Proof. Since the sequence Init(G, e) ∗ (G0, δ) is finite, therefore this can be proved 7→ by induction on the number (n) of actual rewrite transitions in this sequence. Base Case n = 0: this means that there are no actual rewrites in the sequence and therefore G = G0. Inductive Step n = k + 1. First we factorise the sequence into R Init(G, e) ∗ (G, δ0) (G00, δ00) ∗ (G0, δ) 7→ 7→ 7→ where R denotes an actual rewrite transition. 7→ R By using Lem. D.16 on Init(G, e) ∗ (G, δ0) (G00, δ00), we have that Init(G00, e) ∗ 7→ 7→ 7→ (G00, δ00). Since the machine is deterministic we have Init(G00, e) ∗ (G00, δ00) ∗ (G0, δ) with k rewrites transitions. Therefore by using the induction hypothesis7→ on k7→, we have that Init(G0, e) ∗ (G0, δ). 7→ D.9 Termination of Recursion-free Programs

In this section, we prove that programs without recursion always terminate. The proof of termination relies on a unary logical relation, also known as a “logical predicate”. Definition D.25 (Logical predicate for terminating graphs). For any term graph

G : e : κ Γ , the logical predicate for terminating graphs Tκ is inductively defined on κ{ as follows:} →

12:48 Steven W.T. Cheung, Dan R. Ghica, and Koko Muroya

1. κ !Int,!Unit, Cell : G Tκ iff for any dataflow environment E : Λ such that ∈ { } ∈ → ; Γ Λ, (EG, e) . ⊂ ⇓ 2. κ = !(κ1 ¨ κ2): G Tκ if ∈ a. for any dataflow environment E : Λ such that Γ Λ, (EG, e) , and → ; ⊂ ⇓ b. for any term graph H : e : κ Γ such that H T , G H @ T , and 1 1 0 κ1 ( ) κ2 { } → ∈ ⊗ ∈ c. for any for any dataflow environment E : Λ such that Γ Λ if there exists → ; ⊂ some K, X such that Init(EG, e) Final(K, e, X ) and that K can be decomposed into E G then for any term graph7→ H : e : κ Γ such that H T , G 0 0 1 1 0 κ1 ( 0 H @ T { } → ∈ ⊗ ) κ2 . ∈ + Proposition D.18. For any term graphs G1, G2 : e : κ Γ , G1 G2 implies that { } → ≺ G1 Tκ G2 Tκ. ∈ ⇐⇒ ∈ Proof. This is proved by induction on κ.

Base Case κ is a ground type. To show that G1 Tκ = G2 Tκ we need to ∈ ⇒ ∈ + show that for any dataflow environment E, EG2 . Since (EG1, e) and EG1 EG2, ⇓ ⇓ ≺ therefore by using Lem. D.14, (EG2, e) . ⇓

Induction Step κ =!(κ1 ¨ κ2). To show G1 Tκ = G2 Tκ we need to show that (a) G , e , (b) for any term graph H :∈ e : κ⇒ ∈Γ such that H T , ( 2 ) 1 1 0 κ1 G H @ T ⇓ { }E →: ∈ ( ) κ2 , and (c) for any dataflow environment Λ such that Γ Λ ⊗ ∈ → ; ⊂ if there exists some K, X such that Init(EG2, e) Final(K, e, X ) and that K can be decomposed into E G then for any term graph 7→H : e : κ Γ such that H T , 0 20 1 1 0 κ1 G H @ T . (a) can be proved by using similar{ technique} → as the base case.∈ To ( 20 ) κ2 ⊗ ∈ show (b) we simply apply the induction hypothesis on κ2. The other direction can be shown by similar technique. To show (c) we run a sequence from Init(EG1, e) to get + the resulting graph EG10 such that G10 G20 because of Lem. D.9. Since G1 Tκ thus G H @ T , therefore by induction≺ hypothesis G H @ T . ∈ ( 10 ) κ2 ( 20 ) κ2 ⊗ ∈ ⊗ ∈ Definition D.26 (Value trees). A value tree is a tree of !-boxes.

~ + ~ Lemma D.19. For any value tree V : e1 : κ Λ, V C2 C2(V V ). { } → ≺ ⊗ Proof. This is proved by induction on the maximum height h of the value tree.

~ ~ Base Case h = 0. This is true as C2 = C2.

~ ~ Base Case h = 1. This is true as V C2 c C2(V V ). ≺ ⊗ ~ + ~ Induction Step h = k + 1. We need to show that (G!)V C2 C2((G!)V (G!)V ) ≺ ⊗ where the maximum height of V is h and (G!) is a value box. By induction hypothesis ~ + ~ ~ we have (G!)V C2 (G!)C2(V V ) c C2((G!)V (G!)V ). ≺ ⊗ ≺ ⊗ ~ Lemma D.20. For any set of value tress V = V1 : e1 : κ1 Λ1,..., Vm : em : κm Λm, ~ ~ + ~ ~ ~ { } → { } → V C2 C2(V V ). ≺ ⊗ Proof. This is proved by induction on m using Lem. D.19.

12:49 Transparent Synchronous Dataflow

Lemma D.21. For any value dag V : e : κ Γ , there exists some value tree V 0 such + ~ { } → that V CV 0. ≺ Proof. This is proved by induction on the maximum height of V using similar technique as Lem. D.19.

~ Lemma D.22. For any dataflow environment E : Λ and any C : Ω0 Ω such that → ; →~ ~ Ω Λ, there exists another dataflow environment E0 : Λ0 such that EC E0 or EC is⊂ a dataflow environment it self. → ; ≺

Proof. When a C-node in C~ is connected to a $, if, n -node then it is obvious that the resulting graph is a dataflow environment. When{ a}C-node is connected by another C-node, the two will be replaced by a single C-node and the resulting graph would still be a dataflow environment.

Lemma D.23. For any term graph G : e : κ Γ and any set of parallel C-nodes C~ : Γ ω, { } → → ~ G Tκ = CG Tκ (1) ~ ∈ ⇒ ∈ CG Tκ = G Tκ (2) ∈ ⇒ ∈ where CG~ : e : κ ω. { } → Proof. This is proved by induction on κ.

Base Case κ is a ground type. To show (1) we need to show that for any dataflow ~ ~ + environments E, (ECG, e) . First by Lem. D.22 there exists a E0 such that ECG E0G. ⇓ ~ ≺ Since E0G (by assumption) therefore by using Lem. D.14, (ECG, e) . (2) can be shown by similar⇓ technique. ⇓

Induction Step κ =!(κ1 ¨ κ2). To show (1) we need to show that (a) for any ~ dataflow environment E, (ECG, e) , (b) for any term graph H : e1 : κ1 Γ 0 such H T CG~ H @ T ⇓ { E :} → that κ1 , ( ) κ2 and (c) for any dataflow environment Λ such ∈ ⊗ ∈ → ; that Γ Λ if there exists some K, X such that Init(ECG~ , e) Final(K, e, X ) and that ⊂ 7→ K can be decomposed into E0G0 then for any term graph H : e1 : κ1 Γ 0 such that H T , G H @ T . (a) can be proved by using similar{ technique} → as the κ1 ( 0 ) κ2 ∈ ⊗ ∈ base case. To show (b) we simply apply the induction hypothesis on κ2. For (c) since ~ + EC F for some F, we run a sequence from Init(FG, e) to get F 0G0 since G Tκ therefore≺ it is true (2) can be shown by similar technique. ∈

~ Lemma D.24. For any term graph G : e : κ Γ where κ = !(κa ¨ κb) if for any V V T VG~ T V~{ } →V T VG~ @ T where i κi , κ, then for any where i κi , κ . ∈ ∈ ∈ ∈ 0 V~ V T VG~ @ T Proof. We need to show that for any where i κi , κ . Since by assumption ∈ ∈ 0 we have VG~ Tκ therefore by the definition of logical predicate and taking H to be ∈ the empty graph, we have that VG~ @ Tκ . ∈ 0

12:50 Steven W.T. Cheung, Dan R. Ghica, and Koko Muroya

Lemma D.25 (Backward reasoning). For any term graph G : e : κ Γ , if there exists { } → a graph G0 : e : κ Γ such that (I) for any dataflow environment E : Λ such that Γ Λ, Init EG{ , e } → E VG~ , δ for some V~ and δ and (II) for any V~ such→ that ; V T , ( ) ∗ ( 0 0 ) i κi ~ ⊂ 7→ ∈ VG0 Tκ, then G Tκ. ∈ ∈ Proof. This is proved by induction on κ.

Base Case κ is a ground type. Then we only need to prove that it terminates. Assuming a dataflow environmrnt E, because of the assumption of G, we would ~ ~ have Init(EG, e) (E0VG0, δ). Also by assumption we have that VG0 Tκ and thus ~ 7→ ∗ ∈ (E0VG0, e) . Since the machine is deterministic (Prop. D.8), and by using Lem. D.17, ⇓ ~ we have Init(EG, e) (E0VG0, δ) ∗ Final(E00K, e, X ) and thus this case is true. 7→ ∗ 7→

Inductive Case κ = !(κ1 ¨ κ2). To prove (a), it follows the same idea as the base case. As for (b), we need to prove that for any term graph H : e1 : κ1 Γ 0 such that H T G H @ T { } → κ1 , ( ) κ2 . ∈ ⊗ ∈ ~ Assume a dataflow environment E, we would have Init(E(G H)@, e2) ∗ (E0(VG0 H @, δ because of the assumptions such that H T . Notice⊗ that for7→ any changes⊗ 0) ) 0 κ1 ∈ ~ to E, we will always run to a graph in the form of (X 0(YG0 X 0)@. This satisfies the ⊗ assumption (II) of the IH if we take G0 to be G0@. Now by using Lem. D.24, we also have condition (II) of the IH. Therefore we can now apply the IH on κ2 and finally G H @ T G get ( ) κ2 . (c) is obvious because any dataflow environment will take to ~ ⊗ ∈ VG0 which already satisfies the logical predicate by assumption. Lemma D.26 (Fundamental lemma). For any well-typed term Γ t : τ which is ` recursion-free, let G : e : κ Γ = [[Γ t : τ]] any set of recursion-free value trees V~ V : e : {,..., V} →: e : ` V T = 1 1 κ1 Λ1 m m κm Λm such that i κi , { } → { } → ∈

V1 Vm … G

Tκ ∈ ~ S where VG : e : κ Λ and Λ = Λi. { } → Proof. This is proved by induction on the type derivation Γ t : τ. ` x : G V T Base Case Γ τ which means that is empty. Since i ki therefore it is true. ` ∈ Base Case Γ n : Int. In this case since V~ is empty we only need to show that ` for any dataflow environment E : Λ such that Γ Λ, (EG, e) . The proof is straight-forward. → ; ⊂ ⇓

Inductive Step Γ λx.t : τ1 τ2. We need to show that (a) for any dataflow ` → ~ environment E : Λ such that Γ Λ, (EVG, e) , (b) for any term graph H : e1 : κ Γ such that H→ ;T , VG~ H ⊂@ T and (c)⇓ for any dataflow environment{ E : 1 0 κ1 ( ) κ2 } → ∈ ⊗ ∈

12:51 Transparent Synchronous Dataflow

Λ such that Γ Λ if there exists some K, X such that Init(EVG~ , e) Final(K, e, X ) → ; ⊂ 7→ and that K can be decomposed into E0G0 then for any term graph H : e1 : κ1 Γ 0 such that H T , G H @ T . { } → κ1 ( 0 ) κ2 The proof∈ of (a) is straight-forward.⊗ ∈ In order to show (b), we assume a dataflow ~ environment E : Λ such that Γ Γ 0 Λ and run a sequence from Init(E(VG → ; ∪ ⊂ ⊗ H)@, e2):

~ E(VG H)@, (e2, , , ? : , ) (1) ~ ⊗ ↑ E(VG H)@, (e1, , , ? : , ) (2) 7→ ~ ⊗ ↑ ∗ E0(VG H0)@, (e1, , , X : , ) (3) 7→ ~ ⊗ ↓ E0(VG H0)@, (e, , , ? : , ) (4) 7→ ~ ⊗ ↑ E0(VG H0)@, (a, , !, ? : , ) (5) 7→ ~ ⊗ ↑ E0(VG H0)@, (a, , , ? : , ) (6) 7→ ~ ⊗ ↑ E0(VG H0)@, (a, , , (λ, ) : , ) (7) 7→ ~ ⊗ ↓ − E0(VG H0)@, (e, , , (λ, ) : , ) (8) 7→ ~ ⊗ ↓ − E0(VG H0)@, (e2, , , ? : , ) (9) 7→ ~ ⊗ ↑ E0(V (?([[t]]λ)!) H0)@, (e2, , , ? : , ) (10) 7→ ~ ⊗ ↑ E0(V [[t]] H0)@, (e2, , , ? : , ) (11) 7→ ⊗ ↑ where G =?([[t]])λ! and a is the in-port of the λ-node. Going from (2) to (3) we apply the condition on H T and Cor. D.1.1 and thus H is a value dag and H T . Now κ1 0 0 κ1 by using Lem. D.21,∈ we have H + CH~ such that H a value tree and CH~ ∈ T . By 0 ∗ ∗ ∗ κ1 using Lem. D.23, H T . ≺ ∈ ∗ κ1 Now we can use the∈ induction hypothesis on t to get V~ H t T . Then ( ∗)[[ ]] κ2 by Lem. D.23, we have that V~ CH~ t T . Thus by using⊗ Prop. D.18,∈ we have ( ∗)[[ ]] κ2 V~ H t T . Therefore by⊗ using Lem.∈ D.25, we have that VG~ H @ T . ( 0)][[ ]] κ2 ( ) κ2 For⊗ (c), it is∈ straightforward as the resulting graph does not change⊗ and thus∈ the condition is proved in (b)

Inductive Step Γ t u : τ. In this case, we need to show that VG~ Tκ where ~ ` ∈ G = C2([[t]] [[u]])@. ⊗ ~ ~ + ~ ~ ~ First by Lem. D.20 we have that V C2([[t]] [[u]])@ C2(V [[t]] V [[u]])@. There- ~ ⊗~ ~ ≺ ⊗ fore by Prop D.18, it suffices to show that C(V [[t]] V [[u]])@ Tκ. Since by induction ~ ~ ⊗ ∈ hypothesis on t and u, we have that (V [[t]] V [[u]])@ Tκ and then by Lem. D.23, ~ ~ ~ ⊗ ∈ we have that C(V [[t]] V [[u]])@ Tκ. ⊗ ∈ Base Case (Γ op : τ). We are going to show the case for op = $ and op = link. ` Sub-Case Γ $ : Int Int Int. In this case, since V~ is empty, we need to show that G T ` .→ This graph→ indeed terminates and result in the same graph, !(!Int¨!Int¨!Int) ∈ therefore we only need to prove that for any H1 : e1 :!Int Γ 0, such that H1 T!Int, G H @ T . { } → ∈ ( 1) !(Int¨Int) ⊗ ∈

12:52 Steven W.T. Cheung, Dan R. Ghica, and Koko Muroya

To prove the first condition, assuming a dataflow environment E, we would have a sequence Init(E(G H1)@, e2) ∗ Final(E0H10 G, e2, (λ, )) by using the condition ⊗ 7→ − of H1 such that H10 T!Int where e2 is the in-port of the bottom @-node. Therefore it terminates and we∈ then need to prove that H G T . This graph indeed 10 !(Int¨Int) terminates and result in the same graph. Therefore we∈ only need to prove that for any

H2 : e3 :!Int Γ 00 such that H2 T!Int, (H10 G H2)@ T!Int. Since it is of ground type therefore{ we} only → need to prove that∈ it terminates.⊗ Assuming∈ a dataflow environment

E we would have a sequence from Init(E(H10 G H2)@, e3) ∗ (E0(H10 H20 )$, e3, , $, X : ⊗ 7→ ⊗ ↓ S, ). Depending on the value of X , it would transit to either one of the followings: ; E0(H10 H20 )$, (e, , , (n, g) : , ) (12) ⊗ ↓ E0(H10 C H20 C)(n)!, (e, , , (n, ) : , ) (13) ⊗ ↓ − Therefore we have proved that for any dataflow environment, the graph indeed terminates. Since in the first case, e3 will be connected to a dataflow environment, thus we take the resulting term graph to be the empty graph and thus for any dataflow environment it terminates. As for the second case a constant always satisfies the logical predicate. To prove the second condition G H @ T , we need to prove that for ( 1) !(Int¨Int) ⊗ ∈ any H2 : e3 :!Int Γ 00 such that H2 T!Int, ((G H1)@ H2)@ T!Int. The proof is similar to{ the case} → above. ∈ ⊗ ⊗ ∈ Sub-Cases Γ link : Cell Int Unit and Γ assign : Cell Int Unit. These cases are similar` to the $-case→ but also→ needs validity` (Lem. D.2)→ to prove→ that the cell being update exists. Sub-Cases Γ root : Cell Int Unit. This case is similar to the link-case but we also need to argue` that when→ the token→ comes back to perform the r-rewrite, it would always be connected to a dataflow environment as such it will terminate and that the resulting graph satisfies the logical predicate.

Inductive Step Γ if t then t1 else t2 : γ. Since only ground types are allowed in the branches, this case` follows the same technique shown in the previous case.

Proposition D.27 (Termination). For any closed well-typed term t : τ which is − ` recursion-free, Init([[ t : τ]], r) ∗ Final(G, r, X ) for some G, X where X Ansr and r − ` 7→ ∈ is the root of [[ t : τ]]. − ` Proof. This is just a consequence of the fundamental lemma (Lem. D.26).

D.10 Type Soundness

Proposition D.28 (Interface preservation). For any valid state (G, δ) where G : Λ , → ; all transitions send G to another graph G0 with the same interface, i.e.

(G : Λ ) (G, δ) (G0, δ0) = G0 : Λ . → ; ∧ 7→ ⇒ → ; Proof. All the pass transitions indeed satisfy the statement as they do not change the shape of the graph at all. As for rewrite transitions, the proof is done by inspecting them one-by-one.

12:53 Transparent Synchronous Dataflow

Corollary D.28.1. For any valid state (G, δ) where G : Λ , if (G, δ) ∗ (G0, δ0) then → ; 7→ G0 : Λ . → ; Lemma D.29. For any valid state π, either 1. π is a answer state, or

2. there exists some π0 such that π π0. 7→ Proof. This is proved by case analysis on all possible valid states.

Proposition D.30 (Progress). For any closed well-typed term t : τ, if Init([[ t : n ` ` τ]], r) (G, δ) for some G, δ where r is the root of [[ t : τ]], then either (G, δ) is a 7→ ` final state or there exists another state (G0, δ0) such that (G, δ) (G0, δ0). 7→ Proof. Since the initial state is valid therefore this is simply the consequence of Cor. D.2.1 and Lem. D.29.

Theorem D.31 (Type soundness). For any closed well-typed term t : τ, let G : r : − ` { [[τ]] = [[ t : τ]] then } → ; − ` 1. if t is recursion-free then the execution from Init(G, r) will terminate, 2. if t is with recursion then the execution from Init(G, r) will not crash. Proof. This is just a consequence of Cor. D.28.1, Prop. D.27 and Prop. D.30.

12:54 Steven W.T. Cheung, Dan R. Ghica, and Koko Muroya

About the authors

Steven W.T. Cheung is a PhD student at the University of Birm- ingham. Contact him at [email protected].

Dan R. Ghica is a Professor of Semantics of Programming Lan- guages at the University of Birmingham. Contact him at d.r.ghica@ cs.bham.ac.uk.

Koko Muroya is an Assistant Professor at RIMS, Kyoto University. Contact her at [email protected].

12:55