{'fraction_non_alphanumeric': 0.033767190569744594, 'fraction_numerical': 0.010621316306483301, 'mean_word_length': 4.501013171225937, 'pattern_counts': {'":': 0, '<': 5, '<?xml version=': 0, '>': 2, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 2, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Progressive quantization in distributed average consensus

We consider the problem of distributed average consensus in a sensor network where sensors exchange quantized information with their neighbors. We propose a novel quantization scheme that exploits the increasing correlation between the values exchanged by the sensors throughout the iterations of the consensus algorithm. A low complexity, uniform quantizer is implemented in each sensor, and refined quantization is achieved by progressively reducing the quantization intervals during the convergence of the consensus algorithm. We propose a recurrence relation for computing the quantization parameters that depend on the network topology and the communication rate. We further show that the recurrence relation can lead to a simple exponential model for the size of the quantization step size over the iterations, whose parameters can be computed a priori. Finally, simulation results demonstrate the effectiveness of the progressive quantization scheme that leads to the consensus solution even at low communication rate.

with fixed variance then consensus cannot be achieved. The authors in [7] propose a probabilistic quantization scheme that is shown to reach a consensus almost surely to a random variable whose expected value is equal to the desired average. Unfortunately, the scheme performs poorly at low bit rate. Kashyap et al. [8] designed an average consensus algorithm with the additional constraint that the states of the agents are integers. Thus convergence is achieved to some integer approximation of the average of the initial states. Modifications of the classical consensus algorithm have been proposed in [9], [10], including a compensation error term that guarantees that the average is preserved at each iteration. A coding scheme based on predictive coding is proposed in [11] in order to exploit the temporal correlation among successive iterations. Convergence to the true average is shown to be possible under the condition that the quantization noise variance vanishes over the iterations. A different approach for dealing with the quantization noise and additive white noise in general is proposed in [12] and [13] respectively. Both algorithms adapt the weight link sequence in order to guarantee convergence under certain conditions, at a cost of lower convergence rate. In general, all the above mentioned algorithms either maintain the average value in the network but cannot reach a consensus effectively, or converge to a random variable that is not always the target average value.
More recently, the authors in [14], [15] and [16] have proposed quantization strategies that maintain the average of the initial state and at the same time converge asymptotically to the true average value. The quantization scheme introduced in [14] adaptively adjusts the quantization step-size by learning from previous states, at the price of significant complexity and memory requirements. The quantization threshold in [15] is adapted online based on a zoom-in zoom-out strategy, while the set of quantization levels is maintained constant over the iterations. Although these last two solutions perform quite well at high bit rates, the convergence rate appears to be slow when the quantization is coarse. In addition, the stability of both quantization schemes depends on the choice of globally defined parameters that are not easy to determine a priori. Finally, the scheme proposed in [16] is the one that is closer to our work since it is based on the assumption that, as consensus is achieved asymptotically the prediction error of the sensors' states tends to zero. The scaling function is selected in such a way that it decays over time without causing the saturation of the quantizer. However, the proposed scheme leads to very conservative selection of the parameters of the scaling function that prevents reading significant gains in the average consensus performance. On the other hand, our system is able to achieve fast convergence to the true average value in realistic settings, even if it does not provide strict performance guarantees; it relies on average case analysis instead of conservative bounds.
The structure of the paper is as follows. Section II presents our new progressive quantization algorithm. A recursive method for computing the quantization parameters is proposed in Section III, followed by a simple exponential relation for adapting the quantizer step-size. Simulations results are finally presented in Section IV.

II. PROGRESSIVE QUANTIZER FOR DISTRIBUTED AVERAGE CONSENSUS
We consider a sensor network topology that is modeled as a weighted, undirected graph G = (V, E), where V ∈ {1, . . . , m} represents the sensor nodes and m = |V | denotes the number of nodes. An edge denoted by an unordered pair {i, j} ∈ E, represents a link between two sensor nodes i and j that communicate with each other. Moreover, a positive weight W (i, j) > 0 is assigned to each edge if {i, j} ∈ E. The set of neighbors for node i is finally denoted as N i = {j|{i, j} ∈ E}.
The node states over the network at time t can be expressed as a vector z t = [z t (1), . . . , z t (m)] T , where z t (i) represents a real scalar assigned to node i at time t. The distributed average consensus problem consists in computing iteratively at every node the average µ = 1 m m i=0 z 0 (i), where z 0 (i) is the initial state at sensor i. The consensus can be achieved by linear iterations of the form z t+1 = W z t , where the symmetric weight matrix W satisfies the conditions that are required to achieve asymptotic average consensus [17], expressed as where ǫ t (i) models the additive quantization noise of sensor i at iteration t. In particular, in the case of a n-bit uniform quantizer, the quantized values can be written asẑ t (i) = zt(i)−z (min) , when the initial sensor states lie in a finite interval of size S = z . The parameters z (min) 0 and z (max) 0 represent the minimum and the maximum values of the interval respectively. The parameter ∆ = S/2 n is the quantization step-size, which drives the error of the quantizer.
In the presence of quantization noise in the distributed average consensus algorithm, we use the following linear iterations that preserve the average of the initial states [9] where I is the identity matrix. An analytical expression of Eq. (3) shows that the quantization error propagates through the iterations of the consensus algorithm. More specifically, the states z t+1 andẑ t are expressed aŝ The linear iterations defined by Eq.(3) preserve the average of the initial states in the network but unfortunately do not guarantee convergence to the average consensus value in the presence of quantization. In order to limit the influence of the quantization noise, we should decrease the step size by either increasing the number of bits or adapting the quantization range for the same number of bits. In the average consensus problem, it can be observed that as the number of iterations increases, the correlation between the sensors' states increases and the values computed by the sensors tend to converge into an interval of decreasing size. Quantization in the full range of size S hence results in a waste of bits or in limited precision that prevents the algorithm to converge to the true average value. We therefore propose to adapt the quantization step-size as the number of linear iterations increases in a new progressive quantization algorithm. We keep a simple uniform quantizer with a fixed number of bits per sensor and we adapt the quantization range so that quantization becomes finer along the iterations.
In more details, we denote the size of the range of the quantizer in node i at time t as S t (i). Since the size of the quantization range is always positive, we impose S t (i) > 0. This range decreases in each sensor as the iterations proceed. The quantization range is further centered around the previous state of the consensus algorithmẑ t−1 (i) as the values of the consensus algorithm converge over time. More formally, the sensor i encodes its state z t+1 (i) by using a quantization interval that is defined as The data is uniformly quantized in this reduced range, which leads to a step-size that decreases over time. The values falling out of the quantization interval are clipped and coded to the nearest quantizer value. In order to simplify the design of the quantizer for realistic settings, we impose the size of this interval to be identical for all the sensors, independently of their previous state and their position in the network (i.e., S t (i) = S t , ∀i = 1, . . . , m). Since each neighbor node j ∈ N i knows the valueẑ t (i) received at the previous iteration, it is able to perform inverse quantization and to compute correctly the valueẑ t+1 (i). We call the proposed quantization scheme Progressive Quantizer. The important parameter in the Progressive Quantizer algorithm is clearly the size S t of the quantization range. It has to be small enough such that the precision of the quantized information is sufficient for convergence to the true average value. On the other hand, it should be chosen large enough such that the values computed in the network nodes fall in the quantization range with high probability in order to avoid clipping that may negatively affect the convergence of the average consensus algorithm.

III. DESIGN OF THE PARAMETERS OF THE PROGRESSIVE QUANTIZER A. Average case analysis
In this section, we propose a constructive methodology to compute a priori the size of the quantization range, based on the properties of the network topology and the communication constraints. In order to guarantee that the quantizer does not saturate (i.e., all the values fall inside the quantization range), S t+1 should satisfy the following inequality The computation of the worst case interval based on (7) typically leads to conservative progressive quantizer design that does not necessarily lead to to a better performance than the classical uniform quantizer with a constant range. This observations is supported by simulations in subsection IV-C where a conservative design [16] is unable to lead to fast convergence. Instead of looking for strong guarantees such as those in (7), we build our quantizer such that values fall in the quantization range with high probability. This comes at a price of some potential clipping, which however does not significantly penalize the convergence of the algorithm. Moreover, limiting a priori the dynamic range of the sensors' states in a meaningful way is expected to prevent the consensus algorithm from being affected by potential outliers that occur due to quantization noise. The overall procedure could be characterized as an attempt to guide the quantized consensus algorithm such that it converges to the average value with a rate that gets close to the convergence rate of the ideal unquantized consensus algorithm.
In more details, we propose to relate the quantizer range size to the mean square difference z t+1 −ẑ t 2 /m between two successive values. It leads to the following average case condition where · denotes the L2 norm. The expectation of the difference between successive values in the consensus algorithm represents the minimal size of the quantization range at each iteration. Moreover, we model the quantization noise samples as spatially and temporally independent random variables that are uniformly distributed with zero mean and variance ∆ 2 t /12. In the sequel, we first derive in Proposition 1 an upper-bound of E[ z t+1 −ẑ t 2 ] that depends on the previous values {S 1 , ..., S t }. This upper-bound together with (8) permits to estimate S t+1 . Proposition 1. Letẑ t and z t+1 be defined as in Eqs. (4), (5). Let also λ 2 be defined as λ 2 := ρ(W − 11 T m ) and λ min be the smallest algebraically eigenvalue of W . Then, it holds that The proof of Proposition 1 is given in Appendix A. Then, Eqs. (8) and (9) along with the fact that z 0 The computation of the quantizer range size with (10) implies a recursive computation of S t at each time step t of the consensus algorithm. We first set S 0 according to the initial range of the quantizer i.e., and we compute S 1 from a simplified version of (10) where the intermediate term from the right hand side is dropped. Then S t+1 is computed recursively according to (10), where only positive solutions are kept.
Finally, we note that the terms used in the recursive computation of the quantization range reflect the characteristics of the network and the communication constraints. The values of the estimated quantization range depend on the convergence rate of the average consensus algorithm in the absence of quantization noise λ 2 , on the maximum value of the initial data z 0 ∞ , on the network topology W (through λ 2 , λ min ) and on the number of quantization bits n for each sensor. Moreover, we exploit the properties of the weight matrix W by taking into account the averaging effect over the successive iterations. We show in the next section that the recursive computation of the quantization range size can be approximated with a simple exponential model.

B. Exponential quantization range
We build on the convergence behavior of the consensus algorithm and propose an approximate exponential model for the computation of the size of the quantization range. We first pose without loss of generality that S t = 2 · e −βt .
In what follows, we show that under a few simplifying assumptions the recursive relation of the previous section leads to an exponential model whose parameters can be determined in closed form. This closed form parameter computation is of great benefit towards deployment in realistic settings.
When S t = 2 · e −βt , Eq.(10) becomes The second term in the right-hand side of Eq.(11) is due to the accumulated quantization error from the previous t iterations. In particular, the matrix norm W t (W − I) that multiplies the quantization noise vectors decays asymptotically to zero. In addition to that, the sequence defined by Eq.(11) decays to zero as specified by the following proposition.

Proposition 2.
Let e −βt+1 be a sequence defined by Eq. (11). If the condition ( The Proposition 2, whose proof is given in Appendix B, relates the decay and convergence of the size of the quantizer range to the characteristics of the network (through λ 2 , λ min ) and to the number of bits used in the quantization. Eventually, it means that the expected squared difference between consecutive values in the consensus algorithm as defined by the recursive equation (11) goes to zero as long as the number of bits satisfies Then, the following proposition shows that the second term in the right-hand side of Eq.(11) becomes negligible when the number of iterations increases. Proposition 3. Let W be a matrix satisfying the conditions defined in (1). Let e −β0 , e −β1 , ..., e −βt be a sequence such that e −βt ≤ δ, ∀t and lim t→∞ e −βt = 0. Then t−1 s=0 W s (W − I) 2 e −2βt−s−1 converges asymptotically to zero for t → ∞.
The proof or Proposition 3 is given in Appendix C and it is based on the proof of Lemma 5.1 in [18]. Due to the presence of the factor 1/2 2n , the second term of the right-hand side of Eq.(11) decreases faster to zero when the quantization rate is high. This is expected, as this term captures the propagation of the quantization error. Eq. (11) tend to follow an exponential model in this case. We can thus pose β t = α · t + γ, which leads to an exponential decay of the size of the quantization range. We assume that there exists an iteration t 0 where the second term of the right-hand side of Eq. (11) becomes zero. Under this assumption, Eq.(11) simplifies to and by substituting β t = α · t + γ we obtain Since α and γ are constant over the iterations, we choose to determine them from later iterations of the consensus (i.e., t ≥ t 0 ). First, we turn λ 2 into an exponential form by determining α such that λ 2t 2 = e −2α·t holds. This leads to α = − log(λ 2 ).
Eq. (12) then becomes Since β t is linear in t, we observe that e −2βt+1 = e −2(α·(t+1)+γ) = e −2α e −2βt , which permits to simplify (15) to We finally determine γ as We observe that the decay rate α of the exponential function e −(α·t+γ) depends on λ 2 , which characterizes the convergence rate of the average consensus algorithm in the case of non-quantized communication. On the other hand, the parameter γ, apart from the eigenvalues of W , depends also on the number of quantization bits. It is interesting to note that the parameters of the exponential model are similar to the parameters α ′ , γ ′ that characterize the difference between two consecutive time steps in the unquantized consensus problem. In this case, the Euclidean difference between two consecutive time steps is guaranteed to be reduced by the factor W − 11 T /m < 1 at each iteration i.e., where we observe an exponential decrease over time of the form In particular, the rate at which the exponential function decays is the same in both cases (α ′ = α = − log(λ 2 )) while, in the case of quantization, the initial value γ of this decay depends on the number of bits (which is not the case for γ ′ ).
In summary, with our progressive quantizer based on the exponential decay of the quantization range, we force the average difference in the sensors' states between two consecutive steps to decay with the same rate as in the ideal communication. At the same time, we allow the initial magnitude of this difference to be higher for a smaller bit rate in order to take into consideration the quantization error. We emphasize that the above exponential model for S t yet reduces the complexity of the proposed Progressive Quantizer. Instead of estimating a priori the values of the quantization range for a large number of iterations, the system can simply use the parameters α and γ of the exponential model.

IV. SIMULATION RESULTS
In this section we analyze the performance of the Progressive Quantizer in different settings. We consider a network of 40 sensors (i.e., m = 40) following the random geographic graph model, i.e., the sensors are uniformly random distributed over the unit square [0, 1] × [0, 1]. We assume that two neighbor sensors are connected if their Euclidean distance is less than r = (log m)/m, which ensures graph connectivity with high probability [19]. We consider static network topologies, which means that the edge set does not change over the iterations. As an illustration, we consider the Metropolis and the Laplacian weight matrices [17] defined respectively as: • Metropolis weights where d(i) denotes the degree of the i th sensor.
where L denotes the Laplacian matrix of the graph G and the scalar a must satisfy 0 < a < 1/d max , where d max consists of the maximum degree in the network. Moreover, the initial states of the sensors are uniformly distributed in the range [0, 1].

A. Performance of the approximate exponential model
We first validate the exponential model for S t and we use the Metropolis weight matrix for this experiment. We compute recursively the values S t from Eq.(10) for 200 random realizations of a random network topology and communication rates of n = [2, 4, 6] bits. For implementation issues, we fix a parameter δ = 10 −16 . At iteration t, if the quantization range S t is smaller than δ, we quantize with the range computed at the previous iteration i.e., we set S t = S t−1 . All the reported experimental results are averaged over the 200 random realizations of the network topology. In order to compare directly with the proposed exponential model in Section III-B, we plot the values β t that occur when we express the quantization range, computed from Eq.(10), as S t = 2 · e −βt . We observe in Fig.1(a) that the value of β t appears to increase linearly with the number of iterations, which means that the quantization range follows an exponential function that decreases over time. Moreover, the slope of the function β t is independent of the bitrate, while the y-intercept value depends on the number of quantization bits. This is consistent with our approximate model (see Section III-B) and Eqs. (14) and (16), which shows that the slope α is dependent on the convergence rate λ 2 (and hence the network topology) and that the parameter γ is influenced by the communication rate. We further compare the performance of the Progressive Quantizer whose parameters are computed using the approximate linear model (from Eqs. (14) and (16)) with the performance achieved when S t is computed recursively from Eq.(10). Fig.(1(b)) shows the obtained results. We observe that the performance is rather similar in both cases. This implies that the solutions of Eq.(10) can be well approximated with an exponential model whose parameters are easily computed. For this reason, in the rest of our experiments we adopt the approximate exponential model and compute the parameters α and γ of the Progressive Quantizer using Eqs. (14) and (16).

B. Comparison to uniform quantization
We compare the proposed quantization scheme ('ProgQ') with a baseline uniform quantization with a constant range S = 1 ('UnifQ'), for both the Metropolis and the Laplacian weight matrices. Fig. 2 illustrates the average consensus performance corresponding to the absolute error z t − µ1 2 versus the number of iterations for n = [2,4,6] bits. In order to obtain statistically meaningful results we average the error over 200 random realizations of the network topology with random initial values. Observe that the performance of the proposed quantization scheme is very satisfactory even at a very low bit rate (2 bits). In particular, the error z t − µ1 2 shows a decreasing behavior over the iterations, which means that the quantizer does not saturate. It rather follows the evolution of the average consensus algorithm in the noiseless case ('no quant.'). On the other hand, the performance of the uniform quantizer with a constant range saturates quickly even at high bit rate.

C. Comparison to existing quantization schemes for average consensus
We compare the proposed Progressive Quantizer ('ProgQ') with (a) the adaptive quantizer ('AdaptQ') [14], (b) the zoom in-zoom out uniform encoder ('ZoomQ') [15] and (c) the quantization scheme proposed in [16] ('Li et al.'). In particular, the scheme proposed in [14] is based on the Delta modulation with variable step-size. The step-size is adapted throughout the iterations based on the previously sent bits and a constant K. However, the scheme is quite sensitive to the value of K and the performance can deteriorate for non-carefully chosen values. In our experiments we choose K = 1.2 as defined in [14]. On the other hand, the differential encoding scheme proposed in [15] uses a uniform quantizer and the transmitted value is the quantized difference of the current value from the previous estimate, scaled by a factor f that is adapted over time. This factor is similar to the step-size of [14] and it grows or decreases depending on the difference between the new state z t+1 and the previously quantized stateẑ t . The decrease or the increase depends on the constants k in and k out respectively and the way that these constants have to be determined seems to be an open question. In our experiments we choose the parameters k in = 0.5, k out = 2 and the scaling factor f 0 = 0.5 as defined in [15]. Finally, the scheme proposed in [16] is also designed by adapting the scaling function of a difference encoder similar to our quantizer. The value that is quantized at each time step is the difference between the new state z t+1 and the previously quantized stateẑ t while   the scaling function is assumed to have an exponential decay over time. The parameters of the scaling function are defined in an interval form in such a way that the quantizer never saturates. However, one limitation of the scheme in [16] is that the algorithm is designed only for the Laplacian weights of the form W = I − aL, where the parameter a depends on the number of quantization bits. In order to directly compare the performance of the Progressive Quantizer with the quantization scheme of [16], we implement the version of the latter scheme that corresponds to a fixed number of quantization levels (Algorithm 1 in [16] ). The parameters of the scaling function are representative values that belong to the proposed intervals. The edge weights of the matrix W are computed by Eqs. (18) and (19) for the Progressive Quantizer, the adaptive quantizer and the zoom-in zoom-out quantizer while for the quantization scheme of [16] they are computed as defined in the corresponding paper, as they depend on the selected parameters of the scaling function.
We use the same experimental setup as in the previous experiments. Figs 3, 4, 5 illustrate the simulation results and show performance comparisons for the quantizers with different bit rates. Notice first that our scheme outperforms the three above mentioned schemes in all the cases. AdaptQ appears to saturate especially for a small number of bits. The performance of ZoomQ seems to be quite good for 4 and 6 bits, but it suffers significantly at low bit rate. On the other hand, the performance of the last scheme (Li et al.) is quite poor even for 6 bits. This result is quite expected since the proposed intervals for the parameters of the scaling function are too conservative; they are computed such that no clipping appears during the iterative consensus algorithm. Moreover, we observe that both the selection of the weight matrix as indicated in [16] and its dependence on the bit rate penalize even more the convergence rate and the overall performance of the consensus algorithm.
Our scheme bear some resemblance with these three schemes in the sense that we also propose to adapt a scaling function. The scaling function has a very specific definition in our case where it represents the sensors' dynamic range. Moreover, we impose a consistent decay of the quantizer range size which is intuitively supported by the increasing correlation of the sensors' states throughout the iterations. The parameters α and γ that determine the quantization range in our Progressive Quantizer have been carefully designed by taking into consideration both the available number of bits and the topology of the network and they are automatically determined in closed-form from Eqs. (14) and (16). Finally, the performance comparison with the scheme proposed in [16] confirms our initial intuition that very conservative bounds do not necessarily improve the average consensus performance, and that average case analysis is more efficient in practical settings.

D. Convergence of the consensus algorithm
The assumption that the quantizer saturates complicates significantly the convergence analysis of the proposed algorithm. Our Progressive Quantizer may generate some clipping of the values computed by sensors. We have shown through extensive experimental results that this clipping does not significantly penalize the convergence of the consensus algorithm. It can even help in case of strong outliers. Moreover, we have observed that the number of clipping, if any, is small and decays to zero as the iteration of the consensus algorithm increases, as long as the parameter γ is computed according to Eq. (16). However, clipping results into some important non-linear effects that are difficult to analyze. In this subsection, we give some intuition about the convergence properties as well as the convergence speed of the Progressive Quantizer. The simulation results provided in the previous subsections verify that the proposed scheme leads the sensors to converge to the average of their initial values. We notice first that the quantization range reduces to zero as time elapses, leading to an accurate average consensus that is reached independently of the number of bits. The latter is verified experimentally in Fig.6(a), where we observe that, as the range reduces to zero, the absolute error from the accurate consensus value µ becomes smaller.
Moreover, the design of the Progressive Quantizer promotes the decrease of the quantization noise variance over time. By properly decreasing the quantization range, we reduce the quantization noise, as long as the computed values to be quantized fall into that range. We finally relate the convergence of the algorithm to the quantization noise in the following proposition. Similar results have been shown in [11].

Proposition 4. Let σ 2
t be the sample variance of the quantization noise vector ǫ t at iteration t. If σ 2 t → 0 as t → ∞, the sensor nodes converge asymptotically to the true consensus value µ.
The proof of Proposition 4 is given in Appendix D. Fig.6(b) verifies that our scheme leads to a quantization noise variance that converges to zero as time elapses with exactly the same behavior as the quantization range. These results are consistent with the ones shown in Fig.  2. It confirms that the average consensus performance is directly related to the decay of the quantization noise variance and that an accurate consensus is achieved for a variance that converges to zero. Finally, the decay of the noise variance and thus the convergence speed depend on the number of the quantization bits; more precisely the algorithm converges faster for a large number of bits, which is expected.

V. CONCLUSIONS
In this paper, we have proposed a novel quantization scheme for solving the average consensus problem when sensors exchange quantized state information. In particular, our scheme is based on progressive reduction of the range of a uniform quantizer. It leads to progressive refinement of the information exchanged by the sensors while the average consensus algorithm converges. Simulation results show the effectiveness of our scheme that outperforms other quantized consensus algorithms in terms of convergence rate and accuracy of the computed average. Finally, our quantizer represents a constructive simple solution with effective performance in realistic settings. Eq. (4) implies that Let us define Then, we observe that In the formula above, A 1 2 is a deterministic quantity depending on the (fixed) network topology and the initial states of the sensors. We assume that the quantization noise samples ǫ t (i) in (2) are (spatially and temporally) independent random variables that are uniformly distributed with zero mean and variance ∆ 2 t /12, where ∆ t is the quantization step-size at step t. The latter assumption is widely used in the literature [9], [11], [14] for modeling the quantization noise and is true under the conditions specified in [20]. Due to this independence assumption, the two cross terms E[A ⊤ 1 A 2 ] and E[A ⊤ 2 A 1 ] become zero, and (21) simplifies to In the sequel, we work out each individual term separately. First, note that where (a) follows from the fact that W is doubly stochastic and (b) holds because W t − 11 T m 2 = λ t 2 , where λ 2 := ρ(W − 11 T m ). Moreover, where we have again exploited the fact that the quantization noise variables are independent and zero mean. We compute the expectation of the quantization error norms by exploiting the consistently reduced range of the Progressive Quantizer. In particular, the expectation of the error norm at each time step t can be expressed as [20], where ∆ t is the quantization step-size at step t. Hence, the expectation of the second term is bounded as follows We finally derive an upper-bound for E[ z t+1 −ẑ t 2 ] by combining both (23) and (24) and taking into consideration that ∆ 2 t = St 2 n 2 (see also Eq. (6)). Altogether, we obtain Since the eigenvalues of the matrix W lie in the interval [−1, 1], the Proposition 1 follows from the fact that W − I = 1 − λ min and W − 2I = 2 − λ min , where λ min is the smallest algebraically eigenvalue of W .
Equivalently, we can write which indicates that P (t) converges to zero if the following condition is satisfied. Since the sequence P (t) is an upper-bound of the positive sequence e −2βt , if the condition (28) is satisfied, e −2βt also converges to zero.
Hence, using these observations and setting l = t − s − 1, the above inequality can be written as We notice that, since W − 11 T m < 1, e −βt ≤ δ, ∀t and k is finite, the first term of the right-hand side of the inequality converges to 0 for t → ∞. Finally, we can write where we have used the fact that lim t→∞ t−1 l=k+1 W − 11 T m 2(t−l−1) converges to a constant C < ∞.