## 3 Computational Model  
This section describes the computational model for a network represented by a graph \(G=(V,E)\), where the vertex set \(V\) represents the set of processes, the edge set \(E\) represents the network channels, and \(n\) is the total number of processes. The network has one root process, referred to as \(r\), and any two processes in the network, \(i\) and \(j\), are considered neighbors if there is a communication link \((i,j)\) between them, which is represented by \((i,j)\in E\). Each process in the network runs a deterministic program that consists of shared variables, constants, input/output capabilities, and a finite set of guarded commands. All processes except for the root process run the same program, and the processes have knowledge of their neighbors. We assume the shared memory modules model for process communication where a process can only write to its own variables while being able to read its own variables and those of its neighboring processes (Figure 1). The program of a process \(i\) can be expressed as follows:  
\[*[G[1]\to A[1]\,\square\,G[2]\to A[2]\,\square\,\dots\,\square\,G[k]\to A[k]],\]  
where  
* Each \(G[j]\) is a Boolean function of the variables of process \(i\) and the variables of its neighboring processes;
* Each \(G[j]\to A[j]\) is referred to as a _guarded command_[75], where a guard \(G[j]\) is a predicate over the variables of \(p\) and/or its neighbors that evaluates to a Booleanvalue, and a command \(A[j]\) consists of a sequence of statements that updates one or more local variables of the executing process. * Each command \(A[j]\) reads and updates the variables of process \(i\) and reads its neighbors' variables;
* \(*[S]\) corresponds to the repeated execution of the statement \(S\) while there exists an enabled guard. * \(\square\) is called the _nondeterminism symbol_. One of the guarded commands separated by \(\square\) is selected nondeterministically in each iteration. A command is executed only if its corresponding guard evaluates to **True**. A process with a guard evaluating to **True**, and the corresponding command are called _enabled_. If multiple guards are enabled at the same time, the selection of the command to execute is non-deterministic. We assume that the selection of an enabled guard is _weakly fair_ and the execution of the guard and command are performed in a single atomic step. Weak fairness ensures that if a guard remains enabled, it will eventually be executed. Each nodal process contains an application program process and the proposed broadcast algorithm process as shown in Figure 1. The application program is the main program running at each process in the network, supplying a message \(M\) to the root process of the proposed broadcast algorithm to start broadcasting \(M\) to all processes in the system. When input \(M\) is available at root process \(r\), predicate function \(input()\) holds, and the root takes input \(M\) to start broadcasting and disables _input()_\(M\) by executing function \(disable.input()\). Then the proposed broadcast algorithm delivers the message to the application program processes of the system through the actions and communication of the proposed broadcast algorithm processes. The message \(M\) is assumed to be delivered to a process when it changes from the cleaning phase to the broadcasting phase and assumes a parent. The values of a process's variables determine the local state of that process. The _system configuration_ is defined as the product of its processes' states. We refer to the set of all possible configurations of the system as \(C\). Given an execution \(E=\mu_{0}\mu_{1}\mu_{2},...\) for \(i\geq 0\), \(\mu_{i}\in C\), we define the first round of \(E\) to be the minimal prefix \(E^{\prime}\) of \(E\) where every process enabled prior to \(E^{\prime}\) is executed at least once in \(E^{\prime}\). Let \(E^{\prime\prime}\) be the suffix of \(E\) for which \(E=E^{\prime}E^{\prime\prime}\). The second round of \(E\) is the first round of \(E\), and so on.