Tracking an Auto-Regressive Process with Limited Communication per Unit Time

For $\alpha\in(0,1)$, we consider a discrete time auto-regressive process of order 1 (AR[1] process) in $\mathbb{R}^{n}$,

where $(\xi_{t}\in\mathbb{R}^{n},t\geqslant 1)$ is an independent and identically distributed (i.i.d.) random sequence with zero mean and covariance matrix $\sigma^{2}(1-\alpha^{2})I_{n}$. For simplicity, we assume that $X_{0}\in\mathbb{R}^{n}$ is a zero mean random variable with covariance matrix $\sigma^{2}I_{n}$. This implies that the variance of $X_{t}\in\mathbb{R}^{n}$ is $\sigma^{2}I_{n}$ for all $t\geqslant 0$. In addition, we assume that $\lVert X_{t}\rVert_{2}$ has a bounded fourth moment at all times $t\geqslant 0$. Specifically, let $\kappa>0$ satisfy

It is clear that $X=(X_{t}\in\mathbb{R}^{n},t\geqslant 0)$ is a Markov process. We denote the set of processes $X$ satisfying the assumptions above by $\mathbb{X}_{n}$ and the class of all such processes for different choices of dimension $n$ as $\mathbb{X}$.

This discrete time process is sub-sampled periodically at sampling frequency $1/s$, for some $s\in\mathbb{N}$, to obtain samples $(X_{ks}\in\mathbb{R}^{n},k\geqslant 0)$.

The sampled process $(X_{ks},k\geqslant 0)$ is passed to an encoder which converts it to a bit stream. The encoder operates in real-time and sends $nRs$ bits between any two sampling instants. Specifically, the encoder is given by a sequence of mappings $(\phi_{t})_{t\geq 0}$, where the mapping at any discrete time $t=ks$ is denoted by

The encoder output at time $t=ks$ is denoted by the codeword $C_{t}\triangleq\phi_{t}(X_{0},X_{s},\dots,X_{ks})$. We represent this codeword by an $s$-length sequence of binary strings $C_{t}=(C_{t,0},\dots,C_{t,s-1})$, where each term $C_{t,i}$ takes values in $\left\{0,1\right\}^{nR}$. For $t=ks$ and $0\leq i\leq s-1$, we can view the binary string $C_{t,i}$ as the communication sent at time $t+i$. We elaborate on the communication channel next.

The output bit-stream of the encoder is sent to the receiver via an error-free communication channel. Specifically, we assume slotted transmission with synchronization where in each slot the transmitter sends $nR$ bits of communication error-free. That is, we are allowed to send $R$ bits per dimension, per time slot. Note that there is a delay of $1$ time-unit (corresponding to one slot) in transmission of each $nR$ bits. Therefore, the vector $C_{ks,i}$ of $nR$ bits transmitted at time $ks+i$ is received at time instant $ks+i+1$ for $0\leqslant i\leqslant s-1$. Throughout we use the notation $I_{k}\triangleq\left\{ks,\dots,(k+1)s-1\right\}$ and $\tilde{I}_{k}=I_{k}+1=\left\{ks+1,\dots,(k+1)s\right\}$, respectively, for the set of transmit and receive times for the strings $C_{ks,i}$, $0\leq i\leq s-1$.

We describe the operation of the receiver at time $t\in I_{k}$, for some $k\in\mathbb{N}$, such that $i=t-ks\in\left\{0,\dots,s-1\right\}$. Upon receiving the codewords $C_{s},C_{2s},...,C_{(k-1)s}$ and the partial codeword $(C_{ks,0},...,C_{ks,i-1})$ at time $t=ks+i$, the decoder estimates the current-state $X_{t}$ of the process using the estimator mapping

We denote the overall communication received by the decoder until time instant¹¹1The time index $t-1$ in $C^{t-1}$ corresponds to the transmission time of the codewords, whereby the communication received till time $t$ is denoted by $C^{t-1}$. $t$ by $C^{t-1}$. Further, we denote by $\hat{X}_{t|t}$ the real-time causal estimate $\psi_{t}(C^{t-1})$ of $X_{t}$ formed at the decoder at time $t$. Thus, the overall real-time causal estimation scheme is described by the mappings $(\phi_{t},\psi_{t})_{t\geqslant 0}$. It is important to note that the communication available to the decoder at time $t\in I_{k}$ can only depend on samples $X_{\ell}$ up to time $\ell\leqslant ks$. As a convention, we assume that $\hat{X}_{0|0}=0$.

We call the encoder-decoder mapping sequence $(\phi,\psi)=(\phi_{t},\psi_{t})_{t\geqslant 0}$ a tracking code of rate $R$ and sampling period $s$. The tracking error of our tracking code at time $t$ for process $X$ is measured by the mean squared error (MSE) per dimension given by

Our goal is to design $(\phi,\psi)$ with low average tracking error $\overline{D}_{T}(\phi,\psi,X)$ given by

For technical reasons, we restrict to a finite time horizon setting. For the most part, the time horizon $T$ will remain fixed and will be omitted from the notation. Instead of working with the mean-square error, a more convenient parameterization for us will be that of accuracy, given by

The maxmin tracking accuracy $\delta_{n}^{T}(R,s,\mathbb{X}_{n})$ is the fundamental quantity of interest for us. Recall that $n$ denotes the dimension of the observations in $X_{t}$ for $X\in\mathbb{X}_{n}$ and $T$ the time horizon. However, we will only characterize $\delta_{n}^{T}(R,s,\mathbb{X}_{n})$ asymptotically in $n$ and $T$. Specifically, we define the asymptotic maxmin tracking accuracy as

We will provide a characterization of $\delta^{*}(R,s,\mathbb{X})$ and present a sequence of tracking codes that attains it. In fact, the tracking code we use is an instantiation of our successive update scheme, which we describe in the next section. It is important to note that our results may not hold if we switch the order of limits above: We need very large codeword lengths depending on a fixed finite time horizon $T$.

Once the quantized information is sent by the transmitter, at the receiver end, the decoder estimates the state $X_{t}$, using the codewords received until time $t$. Since we are interested in forming estimates with small MSE, the decoder simply forms the minimum mean square error (MMSE) estimate using all the observations till that point. Specifically, for $t\geq u$, denoting by $\tilde{X}_{u|t}$ the MMSE estimate $X_{u}$ formed by the communication $C^{t-1}$ received before time $t$, we know ($cf.$ [44])

The following result presents a simple structure for $\tilde{X}_{u|t}$ for our AR[1] model.

Therefore, the optimal strategy for the decoder is to use the communication sent to form an estimate for the latest sample and then scale it to form the estimate of the state at the current time instant.

The structure of the decoder exposed in Lemma 1 gives an important insight for encoder design: The communication sent between two sampling instants is used only to form estimates of the latest sample. In particular, the communication $C_{ks+1,i}$ transmitted at time $t=ks+i$ must be chosen to refine the previous estimate from $\mathbb{E}[X_{ks}|C_{0},\dots,C_{ks},C_{ks+1,0},\dots,C_{ks+1,i-1}]$ to $\mathbb{E}[X_{ks}|C_{0},\dots,C_{ks},C_{ks+1,0},\dots,C_{ks+1,i-1},C_{ks+1,i}]$. This principle can be applied (as a heuristic) for any other form of the estimate as follows. Let $\hat{X}_{ks|t}$ denote the estimate for $X_{ks}$ formed at the receiver at time $t$ (which need not be the MMSE estimate $\tilde{X}_{ks|t}$). Our encoder computes the error in the receiver estimate of the last process sample at each time instant $t$. Denoting the error at time $t\in I_{k}$ by $Y_{t}\triangleq X_{ks}-\hat{X}_{ks|t}$, the encoder quantizes this error $Y_{t}$ and sends it as communication $C_{ks+1,i}$.

Simply speaking, our encoder computes and quantizes the error in the current estimate of the last sample at the decoder, and sends it to the decoder to enable the refinement of the estimate in the next time slot. While we have not been able to establish optimality of this encoder structure, our results will show its optimality asymptotically, in the limit as the dimension $n$ goes to infinity.

Even within this structural simplification, a very interesting question remains. Since the process is sampled once in $s$ time slots, we have, potentially, $nRs$ bits to encode the latest sample. At any time $t\in\tilde{I}_{k}$, the receiver has access to $(C_{0},\dots,C_{(k-1)s})$ and the partial codewords $(C_{ks,0},\dots,C_{ks,i-1})$ for $i=t-ks$. A simple approach for the encoder is to use the complete codeword to express the latest sample and the decoder can ignore the partial codewords. This approach will result in slow but very accurate updates of the sample estimates. An alternative fast but loose approach will send $nR$ quantizer codewords to refine estimates in every communication slot. Should we prefer fast but loose estimates or slow but accurate ones? Our results will shed light on this conundrum.

In our description of the encoder structure above, we did not specify a key design choice, namely the choice of the quantizer. We will restrict to using the same quantizer to quantize the error in each round of communication. The precision of this quantizer will depend on whether we choose a fast but loose paradigm or a slow but accurate one. However, the overall structure will remain the same. Roughly speaking, we allow any gain-shape [45] quantizer which separately sends the quantized value of the gain $\lVert y\rVert_{2}$ and the shape $y/\lVert y\rVert_{2}$ for input $y$. Formally, we use the following abstraction.

The expectation in the previous definition is taken with respect to the randomness in the quantizer, which is assumed to be shared between the encoder and the decoder for simplicity. The parameter $M$, termed the dynamic range of the quantizer, specifies the domain of the quantizer. When the input $y$ does not satisfy $\lVert y\rVert_{2}\leq\sqrt{n}M$, the quantizer simply declares a failure, which we denote by $\bot$. Our tracking code may use any such $(\theta,\varepsilon)$-quantizer family. It is typical in any construction of a gain-shape quantizer to have a finite $M$ and $\varepsilon>0$. Our analysis for finite $n$ will apply to any such $(\theta,\varepsilon)$-quantizer family and, in particular, will bring-out the role of the “bias” $\varepsilon$. However, when establishing our optimality result, we instantiate it using a random spherical code to get the desired performance.

All the conceptual components of our scheme are ready. We use the structure of Lemma 1 and focus only on updating the estimates of the latest observed sample $X_{ks}$ at the decoder. Our encoder successively updates the estimate of the latest sample at the decoder by quantizing and sending estimates for errors $Y_{t}$.

As discussed earlier, we must decide if we prefer a fast but loose approach or a slow but accurate approach for sending error estimates. To carefully examine this tradeoff, we opt for a more general scheme where the $nRs$ bits available between two samples are divided into $m=s/p$ sub-fragments of length $nRp$ bits each. We use an $nRp$ bit quantizer to refine error estimates for the latest sample $X_{ks}$ (obtained at time $t=ks$) every $p$ slots, and send the resulting quantizer codewords as partial tracking codewords $(C_{ks,jp},...,C_{ks,(j+1)p-1})$, $0\leqslant j\leq m-1$. Specifically, the $k$th codeword transmission interval $I_{k}$ is divided into $m$ sub-fragments $I_{k,j}$, $1\leq j\leq m$ given by

and $(C_{ks,jp},...,C_{ks,(j+1)p-1})$ is transmitted in communication slots in $I_{k,j}$.

At time instant $t=ks+jp+1$ the decoder receives the $j$th sub-fragment $(C_{ks,t-ks},t\in I_{k,j})$ of $nRp$ bits, and uses it to refine the estimate of the latest source sample $X_{ks}$. Note that the fast but loose and the slow but accurate regimes described above correspond to $p=1$ and $p=s$, respectively. In the middle of the interval $I_{k,j}$, the decoder ignores the partially received quantization code and retains the estimate $\hat{X}_{ks}$ of $X_{ks}$ formed at time $ks+(j-1)p+1$. It forms an estimate of the current state $X_{ks+i}$ by simply scaling $\hat{X}_{ks}$ by a factor of $\alpha^{i}$, as suggested by Lemma 1.

Finally, we impose one more additional simplification on the decoder structure. Instead of using MMSE estimates for the latest sample, we simply update the estimate by adding to it the quantized value of the error. Thus, the decoder has a simple linear structure.

We can use any $nRp$ bit quantizer²²2With an abuse of notation, we will use $Q_{p}$ instead of $Q_{Rp}$ to denote an $nRp$ bit quantizer. $Q_{p}$ for the $n$-dimensional error vector, whereby this scheme can be easily implemented in practice if $Q_{p}$ can be implemented. For instance, we can use any standard gain-shape quantizer. The performance of most quantizers can be analyzed explicitly to render them a $(\theta,\varepsilon)$-quantizer family for an appropriate $M$ and function $\theta$. Later, when analyzing the scheme, we will consider a $Q_{p}$ coming from a $(\theta,\varepsilon)$-quantizer family and present a theoretically sound guideline for choosing $p$.

Recall that we denote the estimate of $X_{u}$ formed at the decoder at time $t\geqslant u$ by $\hat{X}_{u|t}$. We start by initializing $\hat{X}_{0|0}=0$ and then proceed using the encoder and the decoder algorithms outlined above. Note that our quantizer $Q_{p}$ may declare failure symbol $\bot$, in which case the decoder must still yield a nominal estimate. We will simply declare the estimate as³³3In analysis, we account for all these events as error. Only the probability of failure will determine the contribution of this part to the MSE since the process is mean-square bounded. $0$ once a failure happens.

We give a formal description of our encoder and decoder algorithms below.

1. 1

   Initialize $k=0$, $j=0$, $\hat{X}_{0|0}=0$.

2. 2

   At time $t=ks+jp$, use the decoder algorithm (to be described below) to form the estimate $\hat{X}_{ks|t}$ and compute the error

   $$Y_{k,j}\triangleq X_{ks}-\hat{X}_{ks|t},$$

   (3)

   where we use the latest sample $X_{ks}$ available at time $t=ks+jp$.

3. 3

   Quantize $Y_{k,j}$ to $nRp$ bit as $Q_{p}(Y_{k,j})$.

4. 4

   If quantize failure occurs and $Q_{p}(Y_{k,j})=\bot$, send $\bot$ to the receiver and terminate the encoder.

5. 5

   Else, send a binary representation of $Q_{p}(Y_{k,j})$ as the communication $(C_{ks,0},...,C_{ks,p-1})$ to the receiver over the next $p$ communication slots⁴⁴4For simplicity, we do not account for the extra message symbol needed for sending $\bot$..

6. 6

   If $j<m-1$, increase $j$ by $1$; else set $j=0$ and increase $k$ by $1$. Go to Step 2.

1. 1

   Initialize $k=0$, $j=0$, $\hat{X}_{0|0}=0$.

2. 2

   At time $t=ks+jp$, if encoding failure has not occurred until time $t$, compute

   $$\hat{X}_{ks|ks+jp}=\hat{X}_{ks|ks+(j-1)p}+Q_{p}(Y_{k,j-1}),$$

   and output $\hat{X}_{t|t}=\alpha^{t-ks}\hat{X}_{ks|t}$.

3. 3

   Else, if encoding failure has occurred and the $\bot$ symbol is received declare $\hat{X}_{s|t}=0$ for all subsequent time instants $s\geqslant t$.

4. 4

   At time $t=ks+jp+i$, for $i\in[p-1]$, output⁵⁵5We ignore the partial quantizer codewords received as $(C_{ks,jp+1},C_{ks,jp+2},\dots,C_{ks,jp+i-1})$ till time $t$. $\hat{X}_{t|t}=\alpha^{t-ks}\hat{X}_{ks|ks+jp}$.

5. 5

   If $j<m-1$, increase $j$ by $1$; else set $j=0$ and increase $k$ by $1$. Go to Step 2.

To describe our result, we define a functions $\delta_{0}:\mathbb{R}_{+}\to[0,1]$ and $g:\mathbb{R}_{+}\to[0,1]$ as

Note that $g(s)$ is a decreasing function of $s$ with $g(1)=1$. The result below shows that, for an appropriate choice of the quantizer, our successive update scheme with $p=1$ (the fast but loose version) achieves an accuracy of $\delta_{0}(R)g(s)$ asymptotically, universally for all processes in $\mathbb{X}$.

We provide a proof in Section VI. Note that while we assume that the per dimension fourth moment of the processes in $\mathbb{X}$ is bounded, the asymptotic result above does not depend on that bound. Interestingly, the performance characterized above is the best possible.

We provide a proof in Section VII. Thus, $\delta^{*}(R,s,\mathbb{X})=\delta_{0}(R)g(s)$ with the fast but loose successive update scheme being universally (asymptotically) optimal and the Gauss-Markov process being the most difficult process to track. Clearly, the best possible choice of sampling period is $s=1$ and the highest possible accuracy at rate $R$ is $\delta_{0}(R)$, whereby we cannot hope for an accuracy exceeding $\delta_{0}(R)$.

Alternatively, the results above can be interpreted as saying that we cannot subsample at a frequency less than $1/\lfloor g^{-1}(\delta/\delta_{0}(R))\rfloor$ for attaining a tracking accuracy $\delta\leqslant\delta_{0}(R)$.

The proof of Theorem 2 entails the analysis of the successive update scheme for $p=1$. In fact, we can analyze this scheme for any $p\in\mathbb{N}$ and for any $(\theta,\varepsilon)$-quantizer family; we term this tracking code the $p$-successive update ($p$-SU) scheme. This analysis can provide a simple guideline for the optimal choice of $p$ depending on the performance of the quantizer.

However, there are some technical caveats. A quantizer family will operate only as long as the input $y$ satisfies $\lVert y\rVert_{2}\leq M$. If a $y$ outside this range is observed is observed, the quantizer will declare $\bot$ and the tracking code encoder, in turn, will declare a failure. We denote by $\tau$ the stopping time at which encoder failure occurs for the first time, $i.e.$,

Further, denote by $A_{t}$ the event that failure does not occur until time $t$, $i.e.$,

We characterize the performance of a $p$-SU in terms of the probability of encoder failure in a finite time horizon $T$.

We remark that $\beta$ can be made small by choosing $M$ to be large for a quantizer family. Furthermore, the inequality in the upper bound for the MSE in the previous result (barring the dependence on $\beta$) comes from the inequality in the definition of a $(\theta,\varepsilon)$-quantizer, rendering it a good proxy for the performance of the quantizer. The interesting regime is that of very small $\beta$ where the encoder failure doesn’t occur during the time horizon of operation. If we ignore the dependence on $\beta$, the accuracy of the $p$-SU does not depend either on $s$ or on the bound for the fourth moment $\kappa$. Motivated by these insights, we define the accuracy-speed curve of a quantizer family as follows.

By Theorem 4, it is easy to see that the accuracy (precisely the upper bound on the accuracy) of a $p$-SU scheme is better when $\Gamma_{Q}(p)$ is larger. Thus, a good choice of $p$ for a given quantizer family $Q$ is the one that maximizes $\Gamma_{Q}(p)$ for $1\leq p\leq s$.

We conclude by providing accuracy-speed curves for some illustrative examples. To build some heuristics, note that a uniform quantization of $[-M,M]$ has $\theta(R)=0$ and $\varepsilon=M2^{-R}$. For a gain-shape quantizer, we express a vector $y=\lVert y\rVert_{2}y_{s}$ where the shape vector $y_{s}$ has $\lVert y_{s}\rVert_{2}=1$. An ideal shape quantizer (which only can be shown to exist asymptotically) using $R$ bits per dimension will satisfy $\mathbb{E}\lVert\hat{y_{s}}-y_{s}\rVert_{2}^{2}\leq 2^{-2R}$, similar to the scalar uniform quantizer. In one of the examples below, we consider gain-shape quantizers with such an ideal shape quantizer.

We illustrated application of our analysis for idealized quantizers, but it can be used to analyze even very practical quantizers, such as the recently proposed almost optimal quantizer in [46].