# How to decode a MIMO stream using V-BLAST?

I am attempting to implement the V-BLAST algorithm for MIMO streams as described by Wolniansky et al. in the following paper: https://ieeexplore.ieee.org/document/738086 (I am not commenting on its useful-ness or how efficient it is, I am simply trying to implement it using the paper as written.)

The algorithm assumes the following:

• The channel, H, is known perfectly (or already assumed).
• It is a rich scattering environment with some number of Transmitters and some number of Receivers, but for simplicity, I myself will assume that the number of Transmitters and the number of Receivers are equal, N.
• The vector of received symbols follows the form r = Ha + n, where H is the channel, a is the encoded transmitted symbols, and n is Additive White Gaussian Noise (unit-mean).

The algorithm is described as follows in the paper:

\begin{align*} &\textrm{initialization:}\\ &(1)i\leftarrow 1\\ &(2)G_1 = H^+\\ &(3)k_1 = \textrm{argmin}_j||(G_1)_j||^2\\\\ &\textrm{recursion:}\\ &(4)w_{k_i} = (G_i)_{k_i}\\ &(5)y_{k_i} = w_{k_i}^Tr_i\\ &(6)\hat{a}_{k_i} = Q(y_{k_i})\\ &(7)r_{i+1} = r_i - \hat{a}_{k_i}(H)_{k_i}\\ &(8)G_{i+1} = H^+_{\overline{k_i}}\\ &(9)k_{i+1} = \textrm{argmin}_{j\not\in\{k_1,...,k_i\}}||(G_{i+1})_j||^2\\ &(10)i\leftarrow i+1 \end{align*}

(An image from the paper can also be found here.)

Some definitions:

• $$H^+$$ is the pseudoinverse of $$H$$. (As in a zero-forcing decoder)
• The algorithm confusingly mixes notations. On (3), $$(G_1)_j$$ is the j-th row of $$G_1$$, but on (7), $$H_{k_i}$$ is the $$k_i$$th column of H.
• $$Q(y)$$ is the quantization (slicing) operation, according to the constellation used.

With that out of the way, I'm getting lost in the implementation. I think I understand it on a surface level, but I get tripped up in the recursion. So then, I have a few questions:

1. In my implementation with QPSK symbols and N = 4, $$r$$ is a vector of size 4x1, and $$G$$ is 4x4. So in line (5), what would the expected size of $$y_{k_i}$$ be? My MATLAB implementation gives me a 1x4 array (row vector), but I'm not 100% certain that's right.
2. What exactly is the Quantization (slicing) operation on line (6)? Is it simply demodulating whatever it is (using qpskdemod in MATLAB), or am I approximating the received points to its nearest points on the ideal constellation? What would the expected size of $$\hat{a}$$ be, a 4x1 row vector?

I think with this I'll be able to fully implement the algorithm in MATLAB. I originally wrote this question going line-by-line with my MATLAB implementation at each line of the algorithm, but the question got really long. I can provide my MATLAB implementation if need be. I'd also greatly appreciate anyone's attempts at a MATLAB implementation so I can fully understand the workings of this algorithm, but that isn't necessarily necessary.

Thank you so much in advance!

In V-BLAST, $$y_{ki}$$ is a scalar (that is, a complex number). It is the (equalized) symbol transmitted by antenna $$k_i$$, with noise.
Keep in mind that all vectors are column vectors ($$n \times 1$$). Then, $$w_{ki}$$ is $$4 \times 1$$, and $$w^T_{ki}$$ is $$1 \times 4$$. Then, $$w^T_{ki} r_i$$ is $$1 \times 1$$, i.e. a scalar.
The "quantization" operation $$Q(y_{ki})$$ consists in finding the constellation element that is closest (in Euclidean distance) to $$y_{ki}$$. So, $$Q(y_{ki})$$ is the estimate of the symbol transmitted by antenna $$k_i$$.
• That makes sense then. So as the recursion continues, the $r$ vector will continually be shaped by each subsequent element? That is to say, if $r$ began as a 4×1 vector, by the end, it will be 4×5, with the final column being the last shape? And where would the symbols to be demodulated be stored, in $\hat{a}$ or in the final column of $r$? Jun 10, 2022 at 20:08
• No, $r$ is always $4\times1$, with one element per receiver antenna. You equalize $r$ to obtain $y$, from $y$ obtain $a$, then remove the effect of $a$ on $r$ and repeat.