Background:
Our goal is to quantize a sequence of floating point numbers generated i.i.d. from a standard Gaussian source and minimize the MSE reconstruction error. We can use two bits for each sample. Moreover, we need to decode efficiently on a GPU, so variable-length codes should be avoided since they are not very parallelizable. However, we can pool samples together, e.g. encode a vector in $\mathbb{R}^8$ with 16 bits.
Since it's a memoryless source, a natural idea is to quantize each sample with two bits. However, empirical experiments indicate that we can get a lower MSE by encoding blocks of 8 samples with the intersection of the E8 lattice and an L-2 ball of radius $\sqrt{10}$ around the origin (bonus question: why is it better than quantizing each sample separately?). The problem is how to decode the quantized samples efficiently, or more specifically, how to map the 16-bit pattern to a vector in E8. A straightforward idea is to use a codebook of size $2^{16} = 65536$. However, observe that all vectors in E8 have an even number of negative components, so we can store the sign for each component with 7 bits and calculate the last one through parity. For the remaining 9 bits, we only need a codebook of size $2^9 = 512$, each entry representing a vector in E8 with at most one negative component. The takeaway is that we can reduce the codebook size drastically by observing that the sign and absolute value are "independent".
Question:
Now we want to use the Leech lattice to encode blocks of 24 samples with 48 bits. This requires a codebook of size $2^{48 - 23} = 33554432$, which is way too large. How can we "partition" the bit pattern into independent bitsets and reduce the codebook size? There are some related questions (e.g. 1, 2), but I don't have a background in DSP or cryptography so it's unclear if that's what we are looking for.
