Symmetric Network Computation

Transcription

1 Symmetric Network Computation and the Finite-State Symmetric Graph Automaton (FSSGA) Model David Pritchard, with Santosh Vempala Theory of Distributed Systems Group at MIT, July David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

2 Overview The standard model puts only weak restrictions on the computational power of each node. We will look at simple models of distributed computation. Motivation: can a simpler model automatically ensure fault-tolerance? What if the network elements are like finite-state automata? Old models: web automata, graph grammars, cellular automata. We call our new model Finite-State Symmetric Graph Automata (FSSGA) uses some qualitative principles that are common to many fault-tolerant algorithms. We don t exactly get what we want (automatic fault tolerance) but the models have some power and are interesting. motivated by unpredictability and leads to algebraic characterization. David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

3 Overview The standard model puts only weak restrictions on the computational power of each node. We will look at simple models of distributed computation. Motivation: can a simpler model automatically ensure fault-tolerance? What if the network elements are like finite-state automata? Old models: web automata, graph grammars, cellular automata. We call our new model Finite-State Symmetric Graph Automata (FSSGA) uses some qualitative principles that are common to many fault-tolerant algorithms. We don t exactly get what we want (automatic fault tolerance) but the models have some power and are interesting. motivated by unpredictability and leads to algebraic characterization. David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

4 Overview The standard model puts only weak restrictions on the computational power of each node. We will look at simple models of distributed computation. Motivation: can a simpler model automatically ensure fault-tolerance? What if the network elements are like finite-state automata? Old models: web automata, graph grammars, cellular automata. We call our new model Finite-State Symmetric Graph Automata (FSSGA) uses some qualitative principles that are common to many fault-tolerant algorithms. We don t exactly get what we want (automatic fault tolerance) but the models have some power and are interesting. motivated by unpredictability and leads to algebraic characterization. David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

5 Outline 1 Background and History Motivating Principles Computing the Network Size An Agent-Based Bridge-Finding Algorithm Some Existing Finite-State Distributed Models 2 Finite-State Symmetric Graph Automata Symmetric Multi-Input Automata The FSSGA Model and Algorithms 2 Afterword Infimum and Passive Mobility Models Further FSSGA Issues David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

6 Problem Statement Computing the Network Size Here s a toy problem to introduce three different computing paradigms: tree-based, agent-based, and decentralized. Problem. Given a network of unknown size and topology, compute the number of nodes in the network. You may assume a leader exists. Note: only one node needs to know the answer, since we could broadcast the information across the network afterwards. This problem is simple but typical for sensor and ad-hoc networks. Also it generalizes to other forms of aggregation such as sums and averages. David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

7 Problem Statement Computing the Network Size Here s a toy problem to introduce three different computing paradigms: tree-based, agent-based, and decentralized. Problem. Given a network of unknown size and topology, compute the number of nodes in the network. You may assume a leader exists. Note: only one node needs to know the answer, since we could broadcast the information across the network afterwards. This problem is simple but typical for sensor and ad-hoc networks. Also it generalizes to other forms of aggregation such as sums and averages. David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

8 Trees Are Bad Consider the following algorithm for counting the number of nodes: 1 Distributively construct a spanning tree 2 Each leaf node reports 1 to its parent 3 Each other node (from the bottom up) sums the values reported to it, adds 1 (for itself) and reports that number to its parent 4 The number reported by the root is V Tree-based algorithms have too fragile a structure to work in a faulty environment. For concreteness in this talk we only consider benign edge/node failures. Even in this model of relatively weak failures, if any edge in the spanning tree fails before the lower node reports to its parent (say right after step 1), then the algorithm fails. There can be Θ( V ) tree edges! David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

9 Trees Are Bad Consider the following algorithm for counting the number of nodes: 1 Distributively construct a spanning tree 2 Each leaf node reports 1 to its parent 3 Each other node (from the bottom up) sums the values reported to it, adds 1 (for itself) and reports that number to its parent 4 The number reported by the root is V Tree-based algorithms have too fragile a structure to work in a faulty environment. For concreteness in this talk we only consider benign edge/node failures. Even in this model of relatively weak failures, if any edge in the spanning tree fails before the lower node reports to its parent (say right after step 1), then the algorithm fails. There can be Θ( V ) tree edges! David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

10 Agent-Based Census An agent may be thought of as a stateful entity that inhabits different nodes of the network and moves from node to adjacent node. Agent-Based Census: we place a single agent in the network. Each node keeps a flag indicating whether the agent has ever been there. The agent counts the number of distinct nodes it has visited. Rule used by agent to determine next destination: take a shortest path to the nearest unvisited node, possibly revisiting some other nodes along the way. We skip details, but the shortest paths can be determined in a simple, fault-tolerant distributed way. Entire traversal takes O(n log n) steps 1. This improves the situation: even if some nodes/edges die, as long as the agent is not in the midst of a failure, and the graph remains connected, the algorithm works. 1 In this talk n = V David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

11 Agent-Based Census An agent may be thought of as a stateful entity that inhabits different nodes of the network and moves from node to adjacent node. Agent-Based Census: we place a single agent in the network. Each node keeps a flag indicating whether the agent has ever been there. The agent counts the number of distinct nodes it has visited. Rule used by agent to determine next destination: take a shortest path to the nearest unvisited node, possibly revisiting some other nodes along the way. We skip details, but the shortest paths can be determined in a simple, fault-tolerant distributed way. Entire traversal takes O(n log n) steps 1. This improves the situation: even if some nodes/edges die, as long as the agent is not in the midst of a failure, and the graph remains connected, the algorithm works. 1 In this talk n = V David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

12 A Decentralized Census Algorithm [Flajolet and Martin, 1985] The agent algorithm still has one critical node whose failure is disastrous. Some algorithms completely avoid having any fragile structure, with no node more important than any other. Often called decentralized. Here s an algorithm to approximately count the number of nodes in a faulty network. Suppose each node has k log 2 V bits of memory, initially all 0. Each node independently sets its ith bit to 1 with probability 2 i, and leaves all bits 0 with the remaining probability 2 k By each node iterating OR with its neighbours, all set bits are broadcast. At end, let l be the minimum unset bit index. Estimate V = 2 l nodes. Can show that this gives Θ(1)-approximation with high probability. Algorithm can tolerate any reasonable failure pattern. David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

13 A Decentralized Census Algorithm [Flajolet and Martin, 1985] The agent algorithm still has one critical node whose failure is disastrous. Some algorithms completely avoid having any fragile structure, with no node more important than any other. Often called decentralized. Here s an algorithm to approximately count the number of nodes in a faulty network. Suppose each node has k log 2 V bits of memory, initially all 0. Each node independently sets its ith bit to 1 with probability 2 i, and leaves all bits 0 with the remaining probability 2 k By each node iterating OR with its neighbours, all set bits are broadcast. At end, let l be the minimum unset bit index. Estimate V = 2 l nodes. Can show that this gives Θ(1)-approximation with high probability. Algorithm can tolerate any reasonable failure pattern. David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

14 A Decentralized Census Algorithm [Flajolet and Martin, 1985] The agent algorithm still has one critical node whose failure is disastrous. Some algorithms completely avoid having any fragile structure, with no node more important than any other. Often called decentralized. Here s an algorithm to approximately count the number of nodes in a faulty network. Suppose each node has k log 2 V bits of memory, initially all 0. Each node independently sets its ith bit to 1 with probability 2 i, and leaves all bits 0 with the remaining probability 2 k By each node iterating OR with its neighbours, all set bits are broadcast. At end, let l be the minimum unset bit index. Estimate V = 2 l nodes. Can show that this gives Θ(1)-approximation with high probability. Algorithm can tolerate any reasonable failure pattern. David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

15 Sensitivity To quantify we mean by more fault-tolerant, we will define the sensitivity of a distributed algorithm. If large parts of the network become disconnected, it is unreasonable to expect a correct answer. At best each connected component can get an answer about itself. At each instant in time, as a function of the network state X, let S(X) (V E) be a set of critical nodes/edges. A critical failure is either the failure of a critical component, or a failure that disconnects two critical nodes. If non-critical failures are harmless, then the sensitivity of the algorithm is the best upper bound that we can ensure on the size of S. Formally, start with G 0 = G. When the ith failure occurs, let G i be a connected component of G i 1 that contains all critical nodes at that time. Let the final answer computed in the nodes of G f be A. By harmless we mean that A is correct for some graph G with G 0 G G f. David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

16 Sensitivity To quantify we mean by more fault-tolerant, we will define the sensitivity of a distributed algorithm. If large parts of the network become disconnected, it is unreasonable to expect a correct answer. At best each connected component can get an answer about itself. At each instant in time, as a function of the network state X, let S(X) (V E) be a set of critical nodes/edges. A critical failure is either the failure of a critical component, or a failure that disconnects two critical nodes. If non-critical failures are harmless, then the sensitivity of the algorithm is the best upper bound that we can ensure on the size of S. Formally, start with G 0 = G. When the ith failure occurs, let G i be a connected component of G i 1 that contains all critical nodes at that time. Let the final answer computed in the nodes of G f be A. By harmless we mean that A is correct for some graph G with G 0 G G f. David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

17 What Properties are Essential? Tree-based counting has sensitivity Θ(n), agent-based census has sensitivity Θ(1), and the Flajolet-Martin algorithm has sensitivity 0. Do the best decentralized algorithms have some similarities? We isolated three properties. (P1) Global Symmetry: the computation proceeds via a single operation that is performed repeatedly by every node. (P2) Local Symmetry: every node acts symmetrically on its neighbours. (P3) Steady State Convergence: the network is brought to a steady state when all nodes perform their operation repeatedly. (Examples: Flajolet-Martin, preflow-push, α synchronizer, harmonic functions, self-stabilizing model) We d like to construct a distributed model with these three properties. David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

18 Outline 1 Background and History Motivating Principles Computing the Network Size An Agent-Based Bridge-Finding Algorithm Some Existing Finite-State Distributed Models 2 Finite-State Symmetric Graph Automata Symmetric Multi-Input Automata The FSSGA Model and Algorithms 2 Afterword Infimum and Passive Mobility Models Further FSSGA Issues David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

19 Symmetric (Agent-Based) Bridge-Finding In a connected network, a bridge is an edge whose deletion disconnects the network. Identifying which edges are bridges is potentially useful in determining the robustness of a network. Consider putting an agent on the graph. Orient each edge arbitrarily and give it a counter initialized to 0. When the agent traverses an edge, change the counter by +1 if the step was in agreement with its orientation, and change the counter by -1 otherwise David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

20 Symmetric (Agent-Based) Bridge-Finding In a connected network, a bridge is an edge whose deletion disconnects the network. Identifying which edges are bridges is potentially useful in determining the robustness of a network. Consider putting an agent on the graph. Orient each edge arbitrarily and give it a counter initialized to 0. When the agent traverses an edge, change the counter by +1 if the step was in agreement with its orientation, and change the counter by -1 otherwise David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

21 Symmetric (Agent-Based) Bridge-Finding In a connected network, a bridge is an edge whose deletion disconnects the network. Identifying which edges are bridges is potentially useful in determining the robustness of a network. Consider putting an agent on the graph. Orient each edge arbitrarily and give it a counter initialized to 0. When the agent traverses an edge, change the counter by +1 if the step was in agreement with its orientation, and change the counter by -1 otherwise David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

22 Symmetric (Agent-Based) Bridge-Finding In a connected network, a bridge is an edge whose deletion disconnects the network. Identifying which edges are bridges is potentially useful in determining the robustness of a network. Consider putting an agent on the graph. Orient each edge arbitrarily and give it a counter initialized to 0. When the agent traverses an edge, change the counter by +1 if the step was in agreement with its orientation, and change the counter by -1 otherwise David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

23 Symmetric (Agent-Based) Bridge-Finding In a connected network, a bridge is an edge whose deletion disconnects the network. Identifying which edges are bridges is potentially useful in determining the robustness of a network. Consider putting an agent on the graph. Orient each edge arbitrarily and give it a counter initialized to 0. When the agent traverses an edge, change the counter by +1 if the step was in agreement with its orientation, and change the counter by -1 otherwise David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

24 Symmetric (Agent-Based) Bridge-Finding In a connected network, a bridge is an edge whose deletion disconnects the network. Identifying which edges are bridges is potentially useful in determining the robustness of a network. Consider putting an agent on the graph. Orient each edge arbitrarily and give it a counter initialized to 0. When the agent traverses an edge, change the counter by +1 if the step was in agreement with its orientation, and change the counter by -1 otherwise David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

25 Symmetric (Agent-Based) Bridge-Finding In a connected network, a bridge is an edge whose deletion disconnects the network. Identifying which edges are bridges is potentially useful in determining the robustness of a network. Consider putting an agent on the graph. Orient each edge arbitrarily and give it a counter initialized to 0. When the agent traverses an edge, change the counter by +1 if the step was in agreement with its orientation, and change the counter by -1 otherwise David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

26 Symmetric (Agent-Based) Bridge-Finding In a connected network, a bridge is an edge whose deletion disconnects the network. Identifying which edges are bridges is potentially useful in determining the robustness of a network. Consider putting an agent on the graph. Orient each edge arbitrarily and give it a counter initialized to 0. When the agent traverses an edge, change the counter by +1 if the step was in agreement with its orientation, and change the counter by -1 otherwise David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

27 Symmetric (Agent-Based) Bridge-Finding In a connected network, a bridge is an edge whose deletion disconnects the network. Identifying which edges are bridges is potentially useful in determining the robustness of a network. Consider putting an agent on the graph. Orient each edge arbitrarily and give it a counter initialized to 0. When the agent traverses an edge, change the counter by +1 if the step was in agreement with its orientation, and change the counter by -1 otherwise David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

28 Symmetric (Agent-Based) Bridge-Finding In a connected network, a bridge is an edge whose deletion disconnects the network. Identifying which edges are bridges is potentially useful in determining the robustness of a network. Consider putting an agent on the graph. Orient each edge arbitrarily and give it a counter initialized to 0. When the agent traverses an edge, change the counter by +1 if the step was in agreement with its orientation, and change the counter by -1 otherwise David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

29 Symmetric (Agent-Based) Bridge-Finding In a connected network, a bridge is an edge whose deletion disconnects the network. Identifying which edges are bridges is potentially useful in determining the robustness of a network. Consider putting an agent on the graph. Orient each edge arbitrarily and give it a counter initialized to 0. When the agent traverses an edge, change the counter by +1 if the step was in agreement with its orientation, and change the counter by -1 otherwise David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

30 Give the Agent a Drink First, no matter how the agent moves, the counter of a bridge will always remain in { 1, 0, 1}. 0 Second, if the agent performs a random walk, it can be shown that each non-bridge edge is expected to exceed ±1 in O( V E ) steps. Proof idea: make a new graph that represents the walker s position and also the counter s value. A special node indicates that the value on the counter exceeds 1 in absolute value. David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

31 Give the Agent a Drink First, no matter how the agent moves, the counter of a bridge will always remain in { 1, 0, 1}. 0 Second, if the agent performs a random walk, it can be shown that each non-bridge edge is expected to exceed ±1 in O( V E ) steps. Proof idea: make a new graph that represents the walker s position and also the counter s value. A special node indicates that the value on the counter exceeds 1 in absolute value. David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

32 Give the Agent a Drink First, no matter how the agent moves, the counter of a bridge will always remain in { 1, 0, 1}. 1 Second, if the agent performs a random walk, it can be shown that each non-bridge edge is expected to exceed ±1 in O( V E ) steps. Proof idea: make a new graph that represents the walker s position and also the counter s value. A special node indicates that the value on the counter exceeds 1 in absolute value. David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

33 Give the Agent a Drink First, no matter how the agent moves, the counter of a bridge will always remain in { 1, 0, 1}. 1 Second, if the agent performs a random walk, it can be shown that each non-bridge edge is expected to exceed ±1 in O( V E ) steps. Proof idea: make a new graph that represents the walker s position and also the counter s value. A special node indicates that the value on the counter exceeds 1 in absolute value. David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

34 Give the Agent a Drink First, no matter how the agent moves, the counter of a bridge will always remain in { 1, 0, 1}. 1 Second, if the agent performs a random walk, it can be shown that each non-bridge edge is expected to exceed ±1 in O( V E ) steps. Proof idea: make a new graph that represents the walker s position and also the counter s value. A special node indicates that the value on the counter exceeds 1 in absolute value. David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

35 Give the Agent a Drink First, no matter how the agent moves, the counter of a bridge will always remain in { 1, 0, 1}. 0 Second, if the agent performs a random walk, it can be shown that each non-bridge edge is expected to exceed ±1 in O( V E ) steps. Proof idea: make a new graph that represents the walker s position and also the counter s value. A special node indicates that the value on the counter exceeds 1 in absolute value. David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

36 Give the Agent a Drink First, no matter how the agent moves, the counter of a bridge will always remain in { 1, 0, 1}. 0 Second, if the agent performs a random walk, it can be shown that each non-bridge edge is expected to exceed ±1 in O( V E ) steps. Proof idea: make a new graph that represents the walker s position and also the counter s value. A special node indicates that the value on the counter exceeds 1 in absolute value. David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

37 New graph, nodes are pairs of (position, value of e s counter): The original graph, and non-bridge edge e highlighted: Random walk on the new graph corresponds to old process on original graph. It is known that a random walk on a connected graph (V, E) hits every vertex in expected O( V E ) time. New graph only constant factor larger than old graph. David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

38 New graph, nodes are pairs of (position, value of e s counter): counter=+1 counter=0 counter=±2 counter= 1 Random walk on the new graph corresponds to old process on original graph. It is known that a random walk on a connected graph (V, E) hits every vertex in expected O( V E ) time. New graph only constant factor larger than old graph. David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

39 New graph, nodes are pairs of (position, value of e s counter): counter=+1 counter=0 counter=±2 counter= 1 Random walk on the new graph corresponds to old process on original graph. It is known that a random walk on a connected graph (V, E) hits every vertex in expected O( V E ) time. New graph only constant factor larger than old graph. David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

40 Outline 1 Background and History Motivating Principles Computing the Network Size An Agent-Based Bridge-Finding Algorithm Some Existing Finite-State Distributed Models 2 Finite-State Symmetric Graph Automata Symmetric Multi-Input Automata The FSSGA Model and Algorithms 2 Afterword Infimum and Passive Mobility Models Further FSSGA Issues David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

41 Review of Finite-State Automata (FSAs) A finite-state automaton consists of a finite set Q of states, an input alphabet Σ, an initial state q 0 Q, a transition function p : Q Σ Q, and an output function β : Q R where R is a finite set of outputs. Traditionally R = {accept, reject}. Let Σ denote the set of strings over Σ. The finite-state automaton defines a function Σ R in the following way. Consider input σ = (σ 1,σ 2,...,σ k ) Σ. Let q denote the current state, initialized to q 0. Then for i from 1 to k, replace q by p(q,σ i ). The output corresponding to input σ is β(q), where q is the automaton s final state. In other words the automaton maps σ to β(p( p(p(q 0,σ 1 ),σ 2 ),σ k )). David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

42 Example of an FSA Picture of an automaton that accepts decimal strings divisible by 3: 0,3,6,9 0,3,6,9 2,5,8 1,4,7 q 2 2,5,8 1,4,7 1,4,7 q 0 q 1 2,5,8 0,3,6,9 For the function f : Σ R defined by the FSA, each set f 1 (r) for r R is called a regular language. (Traditionally a regular language is the set of strings accepted by an FSA). Regular languages can equivalently be defined by regular expressions. When Σ = 1, each language over Σ corresponds (via the length of the strings) to a subset of {0, 1, 2,... }. One can show that such a language is regular iff the subset is a finite union of infinite arithmetic progressions and individual elements. David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

43 Graph Grammars, Web Automata In the 60-70s a number of generalizations of FSAs to graphs were proposed, e.g., by Rosenstiehl, Rosenfeld, Milgram, Mylopoulos. We review some, keeping symmetry in mind. We still assume a finite set of states, but each graph element (node and/or edge, depending on the exact model) maintains a state. Think of a labelled graph, with labels drawn from a finite alphabet. Communication takes place only by elements reading each others states. Can sometimes emulate message-passing by using buffers. Sometimes it is not possible to have pointers to neighbours. In a web automaton we have a single locus of control, like an agent. Depending on the model, one uses existential and/or counting rules like if the agent is in state q 1, and has a l 1 -labelled neighbour v, then it may relabel its node l 2, change to state q 2 and move to v. A graph grammar consists of transition rules of the form labeled subgraph F can be replaced by labeled subgraph H. A language is the family of labeled graphs which can be transformed into some fixed target graph. Generalizes web automata. David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

44 Graph Grammars, Web Automata In the 60-70s a number of generalizations of FSAs to graphs were proposed, e.g., by Rosenstiehl, Rosenfeld, Milgram, Mylopoulos. We review some, keeping symmetry in mind. We still assume a finite set of states, but each graph element (node and/or edge, depending on the exact model) maintains a state. Think of a labelled graph, with labels drawn from a finite alphabet. Communication takes place only by elements reading each others states. Can sometimes emulate message-passing by using buffers. Sometimes it is not possible to have pointers to neighbours. In a web automaton we have a single locus of control, like an agent. Depending on the model, one uses existential and/or counting rules like if the agent is in state q 1, and has a l 1 -labelled neighbour v, then it may relabel its node l 2, change to state q 2 and move to v. A graph grammar consists of transition rules of the form labeled subgraph F can be replaced by labeled subgraph H. A language is the family of labeled graphs which can be transformed into some fixed target graph. Generalizes web automata. David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

45 Graph Grammars, Web Automata In the 60-70s a number of generalizations of FSAs to graphs were proposed, e.g., by Rosenstiehl, Rosenfeld, Milgram, Mylopoulos. We review some, keeping symmetry in mind. We still assume a finite set of states, but each graph element (node and/or edge, depending on the exact model) maintains a state. Think of a labelled graph, with labels drawn from a finite alphabet. Communication takes place only by elements reading each others states. Can sometimes emulate message-passing by using buffers. Sometimes it is not possible to have pointers to neighbours. In a web automaton we have a single locus of control, like an agent. Depending on the model, one uses existential and/or counting rules like if the agent is in state q 1, and has a l 1 -labelled neighbour v, then it may relabel its node l 2, change to state q 2 and move to v. A graph grammar consists of transition rules of the form labeled subgraph F can be replaced by labeled subgraph H. A language is the family of labeled graphs which can be transformed into some fixed target graph. Generalizes web automata. David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

46 Cellular Automata, Lattices, Cayley Graphs Life (Conway) is a highly popularized example of a cellular automaton in 2D. Q = {alive, dead}; all nodes compute synchronously, with the same rule, based on own state and number of of live neighbours. Cellular automata: network topology is an arbitrary lattice. Uses a state space and a set of transition rules telling each node how to evolve based on its neighbourhood. Idea goes back to at least von Neumann. Further generalized by Cayley Graph automata: nodes are group elements, and a generating set S = {s 1,..., s S } defines the edges, Nodes compute as follows: (a, b) E ab 1 S. newstate(a) := transition-function(state(a), state(s 1 a),..., state(s S a)). David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

47 Cellular Automata, Lattices, Cayley Graphs Life (Conway) is a highly popularized example of a cellular automaton in 2D. Q = {alive, dead}; all nodes compute synchronously, with the same rule, based on own state and number of of live neighbours. Cellular automata: network topology is an arbitrary lattice. Uses a state space and a set of transition rules telling each node how to evolve based on its neighbourhood. Idea goes back to at least von Neumann. Further generalized by Cayley Graph automata: nodes are group elements, and a generating set S = {s 1,..., s S } defines the edges, Nodes compute as follows: (a, b) E ab 1 S. newstate(a) := transition-function(state(a), state(s 1 a),..., state(s S a)). David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

48 Cellular Automata, Lattices, Cayley Graphs Life (Conway) is a highly popularized example of a cellular automaton in 2D. Q = {alive, dead}; all nodes compute synchronously, with the same rule, based on own state and number of of live neighbours. Cellular automata: network topology is an arbitrary lattice. Uses a state space and a set of transition rules telling each node how to evolve based on its neighbourhood. Idea goes back to at least von Neumann. Further generalized by Cayley Graph automata: nodes are group elements, and a generating set S = {s 1,..., s S } defines the edges, Nodes compute as follows: (a, b) E ab 1 S. newstate(a) := transition-function(state(a), state(s 1 a),..., state(s S a)). David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

49 Regular and Bounded-Degree Symmetric Models Even if graph doesn t have automorphisms, in the case of -regular graphs we can still make all nodes run identically and symmetrically. Let Q be the set of states. Given an arbitrary -regular graph, we may think of the transition function as f : Q Q Q where we may insist that f is symmetric in its second argument. Generalizes to -bounded degree graphs; add a special deficient symbol ǫ and have f : Q (Q {ǫ}) Q and symmetric as before. But the restriction to bounded degrees seems artificial. We want our new model to be simple, and to work in graphs of unbounded degree. David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

50 Outline 1 Background and History Motivating Principles Computing the Network Size An Agent-Based Bridge-Finding Algorithm Some Existing Finite-State Distributed Models 2 Finite-State Symmetric Graph Automata Symmetric Multi-Input Automata The FSSGA Model and Algorithms 2 Afterword Infimum and Passive Mobility Models Further FSSGA Issues David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

51 Multi-Input Automata We want each node to act symmetrically on its neighbours (local symmetry). We also want all nodes to be the same (global symmetry), regardless of differing degree. Further, we d like to be able to process arbitrarily many neighbours using only finite space. The transition function operates as Q Q Q. For now focus on functions Q Q. Our distributed model will be: with each state q associate a symmetric function f[q] : Q Q; when a node in state q activates, its state is replaced by the output of f[q] using its neighbours states as input. We came up with two reasonable FSA-based models with these properties: sequential and parallel symmetric multi-input automata. David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

52 Multi-Input Automata We want each node to act symmetrically on its neighbours (local symmetry). We also want all nodes to be the same (global symmetry), regardless of differing degree. Further, we d like to be able to process arbitrarily many neighbours using only finite space. The transition function operates as Q Q Q. For now focus on functions Q Q. Our distributed model will be: with each state q associate a symmetric function f[q] : Q Q; when a node in state q activates, its state is replaced by the output of f[q] using its neighbours states as input. We came up with two reasonable FSA-based models with these properties: sequential and parallel symmetric multi-input automata. David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

53 Multi-Input Automata We want each node to act symmetrically on its neighbours (local symmetry). We also want all nodes to be the same (global symmetry), regardless of differing degree. Further, we d like to be able to process arbitrarily many neighbours using only finite space. The transition function operates as Q Q Q. For now focus on functions Q Q. Our distributed model will be: with each state q associate a symmetric function f[q] : Q Q; when a node in state q activates, its state is replaced by the output of f[q] using its neighbours states as input. We came up with two reasonable FSA-based models with these properties: sequential and parallel symmetric multi-input automata. David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

54 Sequential Multi-Input Automata Idea behind the sequential multi-input automaton: when a node activates, it should read each of its neighbours in one-at-a-time; each neighbour causes a state transition. Formal definition, take A finite set W of working states An initial working state w0 A processing function p : W Q W An output function β : W R (output set) If for all q Q, where q = k, for all π S k, the expression β(p(p p(p(w 0, q π(1) ), q π(2) ),, q π(k) )) is independent of π, then (W, w 0, p,β) defines a sequential multi-input automaton. Call (W, w 0, p,β) a sequential program. Computational power is precisely the following: can distinguish between a finite number of symmetric regular languages. David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

55 Sequential Multi-Input Automata Idea behind the sequential multi-input automaton: when a node activates, it should read each of its neighbours in one-at-a-time; each neighbour causes a state transition. Formal definition, take A finite set W of working states An initial working state w0 A processing function p : W Q W An output function β : W R (output set) If for all q Q, where q = k, for all π S k, the expression β(p(p p(p(w 0, q π(1) ), q π(2) ),, q π(k) )) is independent of π, then (W, w 0, p,β) defines a sequential multi-input automaton. Call (W, w 0, p,β) a sequential program. Computational power is precisely the following: can distinguish between a finite number of symmetric regular languages. David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

56 Sequential Multi-Input Automata Idea behind the sequential multi-input automaton: when a node activates, it should read each of its neighbours in one-at-a-time; each neighbour causes a state transition. Formal definition, take A finite set W of working states An initial working state w0 A processing function p : W Q W An output function β : W R (output set) If for all q Q, where q = k, for all π S k, the expression β(p(p p(p(w 0, q π(1) ), q π(2) ),, q π(k) )) is independent of π, then (W, w 0, p,β) defines a sequential multi-input automaton. Call (W, w 0, p,β) a sequential program. Computational power is precisely the following: can distinguish between a finite number of symmetric regular languages. David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

57 Parallel Multi-Input Automata We thought of another reasonable model by which a symmetric multi-input function could be realized: parallel, not sequential. Basic idea: each neighbour contributes a single datum and they are reduced pairwise. result = β(p(, )) p(, ) p(, ) p(, ) α(q 3 ) α(q 2 ) α(q 5 ) α(q 1 ) α(q 4 ) David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

58 Parallel Multi-Input Automata Formally, a parallel multi-input automaton is defined by A finite set W of working states, An input function α : Q W A combining function p : W W W An output function β : W R (output set). On input q, apply α to each element of q, obtaining a multiset of working states. As long as two or more working states remain, remove two of them (say w 1, w 2 ) from the multiset and replace them with p(w 1, w 2 ). When only one working state w remains, output β(w). If the final answer is independent of the order in which the multiset of working states are combined, this defines a parallel multi-input automaton. We call (W, α, p, β) a parallel program. Empty input is a special case which we ignore here. David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

59 Parallel Multi-Input Automata Formally, a parallel multi-input automaton is defined by A finite set W of working states, An input function α : Q W A combining function p : W W W An output function β : W R (output set). On input q, apply α to each element of q, obtaining a multiset of working states. As long as two or more working states remain, remove two of them (say w 1, w 2 ) from the multiset and replace them with p(w 1, w 2 ). When only one working state w remains, output β(w). If the final answer is independent of the order in which the multiset of working states are combined, this defines a parallel multi-input automaton. We call (W, α, p, β) a parallel program. Empty input is a special case which we ignore here. David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

60 Sequential Can Simulate Parallel Lemma Each sequential symmetric multi-input automaton can be simulated by a parallel one. Proof. Idea: if we can divide and conquer, then conquer just one input at a time. Consider a symmetric multi-input function with parallel program (W, α, p, β). Then sequential program (W, w 0, p,β) computes the same function, where W = W {NIL}; w 0 = NIL; p : (w, q) { α(q), p(α(q), w), if w = NIL, otherwise. David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

61 Sequential Can Simulate Parallel Lemma Each sequential symmetric multi-input automaton can be simulated by a parallel one. Proof. Idea: if we can divide and conquer, then conquer just one input at a time. Consider a symmetric multi-input function with parallel program (W, α, p, β). Then sequential program (W, w 0, p,β) computes the same function, where W = W {NIL}; w 0 = NIL; p : (w, q) { α(q), p(α(q), w), if w = NIL, otherwise. David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

62 Sequential Can Simulate Parallel Lemma Each sequential symmetric multi-input automaton can be simulated by a parallel one. Proof. Idea: if we can divide and conquer, then conquer just one input at a time. Consider a symmetric multi-input function with parallel program (W, α, p, β). Then sequential program (W, w 0, p,β) computes the same function, where W = W {NIL}; w 0 = NIL; p : (w, q) { α(q), p(α(q), w), if w = NIL, otherwise. David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

63 Sequential-Parallel Equivalence In fact, we can show that the sequential and parallel models are equivalent. That is, if we can compute a symmetric multi-input function sequentially, we can also do so in parallel. To prove it, define a third model called mod-thresh as follows: Denote Q by {q 1,..., q Q }. Denote by µ i ( q) the multiplicity of q i in q. Atoms are logical statements in the unqualified variable q. mod atom: µi ( q) r (mod m) thresh atom: µi ( q)< t The set of mod-thresh propositions is the closure, under (finite) logical conjunction, disjunction, and negation, of the union of all mod atoms and all thresh atoms. (Side note. Recall characterization of regular languages over single-element alphabets; regular subsets of Z + are exactly those that can be expressed using mod-thresh propositions.) David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

64 Sequential-Parallel Equivalence In fact, we can show that the sequential and parallel models are equivalent. That is, if we can compute a symmetric multi-input function sequentially, we can also do so in parallel. To prove it, define a third model called mod-thresh as follows: Denote Q by {q 1,..., q Q }. Denote by µ i ( q) the multiplicity of q i in q. Atoms are logical statements in the unqualified variable q. mod atom: µi ( q) r (mod m) thresh atom: µi ( q)< t The set of mod-thresh propositions is the closure, under (finite) logical conjunction, disjunction, and negation, of the union of all mod atoms and all thresh atoms. (Side note. Recall characterization of regular languages over single-element alphabets; regular subsets of Z + are exactly those that can be expressed using mod-thresh propositions.) David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

65 Sequential-Parallel Equivalence In fact, we can show that the sequential and parallel models are equivalent. That is, if we can compute a symmetric multi-input function sequentially, we can also do so in parallel. To prove it, define a third model called mod-thresh as follows: Denote Q by {q 1,..., q Q }. Denote by µ i ( q) the multiplicity of q i in q. Atoms are logical statements in the unqualified variable q. mod atom: µi ( q) r (mod m) thresh atom: µi ( q)< t The set of mod-thresh propositions is the closure, under (finite) logical conjunction, disjunction, and negation, of the union of all mod atoms and all thresh atoms. (Side note. Recall characterization of regular languages over single-element alphabets; regular subsets of Z + are exactly those that can be expressed using mod-thresh propositions.) David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

66 Sequential-Parallel Equivalence In fact, we can show that the sequential and parallel models are equivalent. That is, if we can compute a symmetric multi-input function sequentially, we can also do so in parallel. To prove it, define a third model called mod-thresh as follows: Denote Q by {q 1,..., q Q }. Denote by µ i ( q) the multiplicity of q i in q. Atoms are logical statements in the unqualified variable q. mod atom: µi ( q) r (mod m) thresh atom: µi ( q)< t The set of mod-thresh propositions is the closure, under (finite) logical conjunction, disjunction, and negation, of the union of all mod atoms and all thresh atoms. (Side note. Recall characterization of regular languages over single-element alphabets; regular subsets of Z + are exactly those that can be expressed using mod-thresh propositions.) David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

67 Mod-Thresh Functions Definition Let P 1,...,P c 1 be mod-thresh propositions, and r 1,...,r c be elements of R, not necessarily distinct. The function f : Q R described procedurally by procedure f ( q) if P 1 is true then return r 1 else if P 2 is true then return r 2 else return r c is a mod-thresh symmetric multi-input function. Note that a mod-thresh function is automatically symmetric, since it depends on the input q only via the symmetric functions µ i. We have shown Parallel Sequential; will show Mod-Thresh Parallel and then Sequential Mod Thresh, establishing equivalence of all three. David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

68 Mod-Thresh Functions Definition Let P 1,...,P c 1 be mod-thresh propositions, and r 1,...,r c be elements of R, not necessarily distinct. The function f : Q R described procedurally by procedure f ( q) if P 1 is true then return r 1 else if P 2 is true then return r 2 else return r c is a mod-thresh symmetric multi-input function. Note that a mod-thresh function is automatically symmetric, since it depends on the input q only via the symmetric functions µ i. We have shown Parallel Sequential; will show Mod-Thresh Parallel and then Sequential Mod Thresh, establishing equivalence of all three. David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

69 Proof that Mod-Thresh Parallel Need to show that every mod-thresh rule can be evaluated via parallel processing. Key: for every fixed mod-thresh function, there is an integer X such that the function can be evaluated using only the atoms mod X, there are k neighbours in state q i and there are less than X neighbours in state S. Take for example (using the Chinese Remainder Theorem) X = lcm ({all moduli} {max{all thresholds}}). Then to parallel-process, we count multiplicities of all input states. Recall tree picture; each intermediate working state gives a count of the subtree rooted there. Construction: each working state is a Q -tuple of integers in [0, 2X 1]. Input function α maps state q i to (0,..., 0, 1, 0,..., 0). }{{} i 1 The processing function p is addition of vectors, wrapping around 2X + l to X + l. Determine β by evaluating mod-thresh function at specified tuple. David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

70 Proof that Mod-Thresh Parallel Need to show that every mod-thresh rule can be evaluated via parallel processing. Key: for every fixed mod-thresh function, there is an integer X such that the function can be evaluated using only the atoms mod X, there are k neighbours in state q i and there are less than X neighbours in state S. Take for example (using the Chinese Remainder Theorem) X = lcm ({all moduli} {max{all thresholds}}). Then to parallel-process, we count multiplicities of all input states. Recall tree picture; each intermediate working state gives a count of the subtree rooted there. Construction: each working state is a Q -tuple of integers in [0, 2X 1]. Input function α maps state q i to (0,..., 0, 1, 0,..., 0). }{{} i 1 The processing function p is addition of vectors, wrapping around 2X + l to X + l. Determine β by evaluating mod-thresh function at specified tuple. David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49

71 Proof that Sequential Mod-Thresh Fix a sequential rule. Fix q i Q. By symmetry-invariance of sequential model, we may always choose to process first all copies of state q i that occur in the input. Define x 0 = w 0 and x j = p(x j 1, q i ) for j > 0. After processing all µ i ( q) copies of q i, the working state is x µi ( q). The (infinite) trajectory through the working state space is illustrated below Forms a rho (like Pollard s ρ factoring algorithm) Since x 15 = x 7, mod-thresh behaviour for this example is (x a = x b )&(a b) (a, b 7)&(a b mod (15 7). David Pritchard (U Waterloo) Symmetric Network Computation TDS at MIT, 7/7/ / 49