Frame Based Codes for Partially Active NOMA
11 TEL AVIV UNIVERSITY
Frame-based codes for partially active NOMA By Maya Slamovich
Supervisor:
Prof. Ram Zamir
Abstract
Non-orthogonal multiple-access (NOMA) is a leading technology which gain a lot of interest this past several years. It enables larger user density and therefore is suited for modern systems such as 5G and IoT. In this paper we examined different frame-based codes for a partially active NOMA system. It is a more realistic setting where only part of the users, in an overly populated system, are active simultaneously. We introduce a new analysis approach were the active user ratio, a system’s feature, is kept constant and different sized frames are employed. The frame types were partially derived from previous papers on the subject [1] [2] and partially novel such as the LPF and the Steiner ETF. We learned the best capacity achieving frame depends on the active user ratio and three distinct ranges where defined. In addition, we introduced a measure called practical capacity which is the maximal rate achieved by simple coding scheme. ETF always achieves the best practical capacity while LPF and sparse frame are worse than a random one.
Contents
Abstract_____________________________________________________________2 _________________________________________________________ – Low Pass Frame __________________________________________________ – Equiangular Tight Frame ___________________________________________ _____________________________________________________________ ______________________________________________ _______________________________________________________________ __________________________________________________ ___________________________________________________ ___________________________________________ _______________________________________________________ – sparse matrix generation __________________________________ – LPF generation ___________________________________________ ___________________________________ ______________ ___________________________ Introduction
Up until recent years Orthogonal multiple-access (OMA) was the optimal transmission design for multiple-access communications. It achieves the ultimate total throughput in a fully loaded Gaussian channel, where the number of users equals the total number of available orthogonal resources. These resources can be time slots in a TDMA system, frequency bands in an OFDMA system, code sequence in a CDMA system and more. With the rising demand for larger user density in current technologies such as IoT and 5G, the non-orthogonal multiple access (NOMA) scheme is gaining popularity. The NOMA scheme targets overloaded regimes, where the number of potential users exceeds the number of available resources. NOMA can be roughly split into two domains – power and code. This paper will examine the latter. In our paper we consider a partially active NOMA system for which different transmission schemes will be evaluated. We start with a fully active NOMA system where the signals of N users are multiplexed over M shared orthogonal resources: y c F x n = + X is a N-dimensional complex vector comprising the coded symbols of the users. Assuming no cooperation between encoders and gaussian signaling, the input vector x in distributed as (0, ) N x CN I . n denotes the n-dimensional complex additive white gaussian noise vector (0, ) M n CN I . F denotes the MxN user-resource mapping (user n occupies resource m if ,n m F . c is a normalization factor which is set so that: ( ) ... , 1... NM M MiM i
F f f fc f x SNR i N = = =
The parameter SNR thus designates the received signal to noise ratio of each user. In addition, we define NM − as the system load (resources per user). Now we can generalize the model to fit a partially active NOMA system which is a more realistic setting where not all users are active simultaneously. The active users are randomly selected according to Bernoulli(p) distribution. This means we are only interested in a random subset of the frame vectors, or columns of F. In other words, each of the vectors ... NM M M f f f is erased from the frame with probability p − . We define the subframe as: iMM i F fpN N = = However, for model simplicity, we chose a constant number of active users
K p N = . The active users are chosen uniformly at random from N . So in total the random subframe is defined as: iM K M i F fK pN N == = Notice that the fully active NOMA system is equivalent to a partially active one with p=1. we define K pNM M = as the system’ s active load (number of active users per resource). Throughout this paper we evaluate and compare four different mapping approaches ( F frame) between users and resources: 1. Regular sparse mapping [2] – sparse spreading codes comprising only a small number of non-zero elements. Its main advantage is its inherent receiver complexity reduction. The mapping is dubbed regular when each user occupies a fixed number of resources and each resource is used by a fixed number of users, i.e. each column of F contains a constant d + number of nonzero values and each row d − + nonzero values. Irregular is when the respective numbers are random and only fixed on average. Regular mapping is superior to irregular mapping so we will focus on the former. 2. Low pass frame (LPF) – A type of unit-norm tight frame (UNTF) which is constructed by taking the upper
M N section of a N N DFT matrix. Mapping using a UNTF was proven analytically to maximize the channel capacity for the fully active (p=1) case [3]. More on the frames structure in the next chapter. 3.
Equiangular tight frame (ETF) – ETFs are the closest equivalent of orthonormal bases in terms of incoherence. All distinct pairs of column vectors of F have the same cross correlation , i j f f const = . ETFs where shown to minimize the d-th order moments of a partially active setting [4]. More on the frames structure in the next chapter. 4. Gaussian i.i.d. Frame – a frame which has i.i.d (independent and identically distributed) normal entries with zero mean and M variance. We will start with a review on frame theory, different characteristics and importance. Then we will present our frame generation algorithms and elaborate on the system's analysis and results. We will conclude with final discussions and future studies to be performed. All codes are attached as appendixes at the end of this document. Frame Theory
The general focus of Frame Theory is the study of overcomplete representations of orthonormal bases. Its theorems and conclusions can be employed to better understanding of our mapping problem. A matrix
M N F with M N is a frame over the finite Hilbert space M if its linearly dependent column vectors N Mn n f = satisfy:
22 21 , ,
N Mnn a y f y b y y = Where the finite coefficients a b are referred to as the frame bounds. A frame is said to be tight if a b = leaving us with: , , N Mnn f y a y y = = Which is equivalent to a frame satisfying:
H M
FF aI = A tight frame is called a UNTF when all vectors N Mn n f = are unit-norm, which further implicate that Na b M − = = = meaning: Equation UNTFH M
NFF IM = Now we define the vector s’ cross correlation: , , ,1 , ' Mn k n k n k i n i ki c f f f f F F = = = Where for UNTF: i i i c f = = The Welch Bound lower bounds the mean-square (ms) cross correlation [5]: ( )
1( 1) ( 1)
Nms n kn k
N MI F cN N N M −− − And is achieved with equality iff F is a UNTF. The Welch Bound implies a bound on the maximum-square cross correlation [5]:
Equation ( ) max ( 1) n kn k N N MI F c N M − −
We define an Equiangular Tight Frame (ETF) as a UNTF which satisfies: ( 1) n k N Mc const n kN M −= = −
An ETF, as explained before, is the closest equivalent of orthonormal bases in terms of incoherence. Meaning, it’s a UNTF with the maximal spatial angular displacement of the frame vectors pairs ( , ), n k f f n k . Which means ETF achieves the max-WB with equality. The existence of ETF is limited to particular dimensions pairs ( , ) M N and is not easily generated. Frame Generation
Sparse Frame
Sparse frames were constructed according to the description in [2]. The frame is of size MxN with exactly d + non-zero entries in each column, and d − + non-zero entries in each row . Each non-zero element is uniformly distributed over the unit circle in . Meaning d − is limited to normal numbers only. Code can be found on appendix 8.1. In order to verify our implementation, we compared the eigenvalues' pdf of H FFd , calculated using our implementation, to the theoretical one (given in [2]). Looking at Figure 1 you can see we got a good match.
Figure 1- comparison between thoretical sparse matrix eigenvalues' pdf to the simulated one
LPF – Low Pass Frame
A LPF construction is relatively easy. You simply create a DFT matrix of size N and erase the last N-M rows. Afterwards you normalize each column to unit norm. In addition, we verified the frame satisfies Equation
1. Code can be found on appendix 8.2.
ETF – Equiangular Tight Frame
As explained before, an ETF is a frame with normalized vectors that achieves the Max Welch bound. Meaning that the inner product of its vectors equals ( ) N MM N − − . An ETF does not exist for every (M,N) combination but rather only for specific ones. Over the years several methods of construction where developed. In this paper we used two of them – the difference sets method and Steiner method. Difference sets
A difference set D is a collection of k distinct residues ,..., mod k d d , for which the congruence (mod ) i j d d b − = has exactly distinct solution pairs , i j d d in D for every b . Each difference set is defined by the values ( ) , , k . For example a difference set ( )
7, 3,1 can be the group because we can get any number in ( ) by substituting one pair in the set. It was shown in [6] that by collecting rows from a
N N DFT matrix which are indexed by D you can construct an M N ETF if and only if D is a difference set with N = and k M = . This means we can construct ETFs rather easily by using difference sets. There are several known families of difference sets. In our paper we used the Paley family which is
11, ,2 ii pp ++ p i provided that p is a prime number and i . Using this family, we constructed ETFs with MN = = . The construction of ETF using the Paley difference set method has low complexity and can ber computed using Matlab. Steiner equiangular tight frames
In [7] a new method for constructing ETFs was presented. The steps are as follows: 1.
It start with the transposed incidence matrix of a ( )
2, , k v - Steiner system which has the following characteristics: a. v columns b. ( )( ) b k k −= − rows c. every row contains k elements d. every column contains r k −= − elements e. any pair of elements is contained in exactly one row. For example – a ( )
2, 2, 4 - Steiner system whose transposed incidence matrix is: T A + + + + + += + + + + + + This is a matrix with ones and zeros (+ implies one). 2.
Next, construct a matrix with unimodular entries (absolute value equals one) and orthogonal rows of size
N Nv v such as a Hadamard matrix or a DFT matrix. For example – for N = we can choose a Hadamard matrix: 0 H + + + + + − + − = + + − − + − − + To form F , in each column of T A we replace each 1-valued entry with a distinct row of H and normalize the columns. One may choose a different sequence of rows of H for each column. For example – always choosing the second, third and fourth rows yields an ETF: F + − + − + − + − + + − − + − + − + − − + + − + −= + + − − + + − − + − − + + + − − + − − + + − − + You can verify the rows of F are orthogonal and have constant norm which equals to NM , implying F is a UNTF. One can also easily see that the inner products of two columns from the same block are − , while the inner products of columns from distinct blocks are , giving us in total an ETF frame. A recursive code was written in order to construct the T A matrixes used in the Steiner method. On each function call a row of T A was populated by one of the combinations available (a combination that doesn’t violate any of the matrix's requirements). If a row can't be populated without violating the requirements a fail message is returned so the previous call will choose a different population option from the ones possible. Code can be found on appendix 8.3. Unfortunately, the computing complexity of the code was quite high and would have taken several days, if not weeks, to finish, especially for the larger matrixes. As a result, I decided to apply parallel computing and use Google Cloud's multi-core machines. This version of the code can be found on appendix 8.4 . A log of the machine's CPU usage is given in Figure so you could see that for really large matrixes the code run for a whole two weeks even on the cloud. 1 Figure - cloud machine's CPU log Verification
It was proven that the pdf of the eigenvalues of a random subset of an ETF is equal to the Manova distribution [1]. We will verify this fact in order to check our ETF's construction process.
Figure 3 - comparison between random subset of ETF's eigenvalues' pdf to the Manova distribution
You can see from Figure 3 we got a good match between the distributions so we can feel confident about our ETF implementation.
Gaussian i.i.d. Frame
As explained before, this is a frame which has i.i.d (independent and identically distributed) normal entries with mean zero and variance M . The chosen variance guarantees unit normalized vectors, meaning:
22 , ii M N ff → = ⎯⎯⎯⎯→ The construction is straight forward and is given in 8.5. In order to verify our implementation, we compared the eigenvalues' pdf of a random subset of the frame to the Marcenko-Pastur density [1]. Looking at Figure 4 you can see we got a good match. 2
Figure 4 - comparison between random subset of gaussian iid frame's eigenvalues' pdf to the Marcenko-Pastur distribution Performance measures
In order to evaluate and compare the different frames’ performance we used four d ifferent measures which can be divided into two main types: 1.
Capacity – the channel capacity of a linear Gaussian channel was proven to be [8]: ( ) ( ) [ / ] log det H C bits s I SNR F F = +
The capacity can be re-written as a function of the eigenvalues:
Equation ( ) ( ) ( ) ( )
22 211 [ / ] log detlog 1 log 1
HK Ki iii
C bits s I SNR F FSNR SNR == = + = = + = + Where i are the eigenvalues of H FF . 2. Practical capacity – It’s well known that the system capacity is the higher bound on the achievable rate of a system. Achieving it will most likely require extremely sophisticated and complex coding schemes. For simple systems, we introduce a more practical bound, achievable using simple schemes, which we call the practical capacity. It will also help us visualize and evaluate the effect of eigenvalues and SNR on the system. Practical capacity is defined as:
Equation ( ) ( ) [ / ] log det Hp C bits s SNR F F =
And as a function of the eigenvalues: ( ) ( ) ( )( ) [ / ] log log loglog log
K Kp i ii iK ii
C bits s SNR K SNRK SNR = == = = + = = +
Each of the measure types above can be normalized per user or per resource giving us a total of four measures: 1.
Capacity per user: ( ) ( )
1/ / user log det H C bits s I SNR F FK = + Capacity per resource – also known as spectral efficiency when the resources are frequency bands: Equation ( ) ( ) ( ) ( )
1/ / resource log det1 log det / / HH C bits s I SNR F FMK I SNR F F C bits s userM K = + == + =
4 3.
Practical capacity per user: ( ) ( )
1/ / user log det Hp C bits s SNR F FK = Practical capacity per resource: / / resource / / p p
C bits s C bits s user = Analysis
Fully active NOMA system
On [2] they showed the superiority of sparsed frames over different allocation techniques regarding capacity per resource for classic NOMA systems. In our paper we first concentrated on reproducing those results and comparing them to additional frame structures.
Figure - [1] results reprodution for fully active NOMA system with additional fames The reconstruction was successful, as can be seen in Figure . The sparser the frame, the higher the capacity per resource and its obviously superior to the random one. On the other hand, the sparser the frame the less values we can choose as d − must be a natural number. For example if d = − can take any of the following values
1, 1.1, 1.2, ... − where as if d = we are left with fewer options
1, 1.5, 2 ... − . It can be seen that a UNTF (uniform tight frame) of any kind, achieves higher capacity and is the best mapping approach from the ones examined. Choosing an ETF isn’t worthwhile since it shows no improvement over a simple UNTF. It’s interesting that the capacity when using an UNTF is not affected by . The reason for that is that the simulation was made for constant b EN which cancels out the effect as can be seen here: ( ) ( ) b H F is UTFM bESNR C N
SNRC I SNR FF I IM M ESNR SNR CM N = = + = + = = + = + = +
6 Moving forward, all the analysis will be made for constant SNR rather than constant b EN . On Figure 6 you can see similar results for constant SNR rather than b EN . A sparse matrix is still superior to a random one but they both achieve lower capacity than a UNTF. Pay attention that now the capacity achieved by an UNTF is dependent on . Figure 6 - Capacity of fully active NOMA system for diferent frames for SNR=30dB Partially active NOMA system
We now examine a more realistic setting where only K of all users are active at the same time. Remember, we defined K pNM M = as the system active load (number of active users per resource).
Results reproduction
We start with reproducing the results given in [1]. The paper simulated the capacity per user for an ETF frame and random i.i.d gaussian frame for different system loads ( ) . It didn’t specify the SNR for which the results where obtain but from comparing to our results (Figure 7) we can infer they were obtained for SNR dB = . Figure 7 – capacity comparison for different frames vs the system load ( β ) for SNR= 0dB and 30dB Note we started analyzing the achieved capacity per user first rather than the capacity per resource. We claim there is no point in overloading the system to achieve better spectral efficiency at the expense of the user quality of service. We first must make sure our capacity per user is within reason and then try to make the most of our resources. As you can see, in a partially active setting there is a difference between using ETFs or UTFs. As proven in [4] the performance of ETFs is superior to all other frames. setup After much thought we came to the conclusion that this kind of analysis doesn’t represent the system well. In paper [1], they chose to keep constant and change p in order to change . However, p is a characteristic of the system and as such should be kept constant within a plot. In order to plot the capacity vs , needs to change to maintain the ratio p = constant. Generating frames with different ratios is not a problem except for ETFs. As mentioned earlier ETFs exist only for specific M, N pairs i.e. specific ratios. One of the simplest methods of construction is for families with ration = . As a result, most papers concentrate their analysis on = ETFs exactly like [1].
However, using the Steiner method we were able to construct ETFs with various ratios and in doing so improve the analysis by keeping the parameter p constant. While constructing the ETFs we encountered two questions: 1. The Steiner logarithm is quite complex and takes a long time to finish. The larger the frame the longer the running time will be. We wanted to know what is the minimal frame size that will result in enough statistics. 2.
ETFs with different have also different sizes. Meaning M is not constant but rather changes from frame to frame. The question is whether the number of resources (M) effects the capacity achieved or does only the ratio effect it? In order to answer both questions, we constructed several ETFs with the same ratio = and different number of resources M. First, for some p , we calculated the variance of the achieved capacity after 50 iterations. As you can see from Figure 8 for M we get sufficiently deterministic results. Figure 8 - Variance of achieved capacity for ETFs with different M values
9 Second, for several p 's, we calculated the capacity of the system for the different M's values (averaged over 50 iterations). As you can see in Figure 9 for M M has no effect on the capacity. The affect for smaller M is due to lack of determinism. In conclusion, from both result we have learned to use only frames of size M bigger than 50 to receive valid results.
Figure 9 - capacity for ETFs with differnet M values Results
Let us review the capacity achieved by the different frames and how affects it. Remember, we keep p constant so also changes with in order to keep p = . In addition, keep in mind that for sparse frames d − is limited to natural numbers only, so not all combinations of , are possible. For example, for p d = then only one pair of , is possible: dp p − − − = → = → = = → = . We will focus on the range . An interesting observation is that for the same , the larger p is the larger the capacity per user (except from random frames which are not affected by p ). Meaning that for a given final system load (final number of users per resource) we will get larger capacity if the original load was small with high probability of user participance than large load and small probability of participance. The reason for this is that we did the user-resource allocation without knowledge of the final participance status, so the smaller the original load was the smaller the final probability of user to user interference will be. In addition, its logical that random frames are not affected by the user participance ratio because its random, so for every subframe we choose, the statistical characteristics remain the same. Figure 10 - Capcity per user vs β for different frame types and p. SNR = 30dB. The sparse frame was constructed with d=2. γ =p/ β.
1 However, as said before, the user participance ratio p is given for each system and we can't control it. So the question is - given a constant p what are the best , pair and frame type we can choose to improve our system's performance? Regarding the preferable frame type, we must devide our answer in three: 1.
For small p ( p ) the random frame gives suprisingly good results which are better from all other frames with the exeption of ETF. However, the ETF advantage is almost neglectable (smaller than half a bit) so its probably preferable to work with randome frames to gain system simplisity. 2. For median p ( p ) the ETF's superiority is more dominant and may be the favorite choise despite the added complexity to the system. It ’ s notable that the LPF converges to the ETF's capacity for small but this won’t be a good operating point as will be shown in Figure 11. 3. For large p ( p ) there is almost no difference between the performance of an ETF and a LPF as can be seen from Figure 10 and Figure 6 (for p = ). So, the preferred choice would be a LPF in order to reduce system complexity. From Figure 10 it’s clear that the smaller is, the higher the user capacity. This makes sense since lowering our system's final load decreases the probability of user to user interference. However, decreasing lowers our system efficiency (Figure 11). There is no obvious optimal operating point but rather a trade-off between the two. Figure 11 - capacity per resource vs β for different frame types and p. SNR = 30dB. The sparse frame was constructed with d=2. As → the eigenvalues grows smaller achieving zero at = , which will cause the capacity per user to decrease significantly (Equation ). If the slope of the capacity per user vs − is higher than one (higher than the slope caused by the multiplication with ; Equation ) , we should have gotten a maximum point at .
2 Meaning, a zeroed eigenvalue could have caused a maximum point at for the capacity per resource and as a result, an obvious optimal operating point. Which raises the question – why does the capacity per resource decreases monotonically with − ? The hypothesis was that the identity matrix in the equation was preventing the capacity per user to decrease significantly when → . If we omit the identity matrix we get: ( ) ( ) ( )( ) ( ) ( ) ( ) ( ) K Ki ii iKK iiLGM
C bits s user SNR SNRK KSNR SNR LGMC bits s resource C bits s user SNR LGM = = →= = = + = + = + ⎯⎯⎯→ − = = + LGM, stands for Log Geometric Mean. Meaning, if we omit I, the capacity per user goes to − when → . This will cause the capacity per resource to increase with − at → and enable us to deduce an optimal operating point. Figure 12 – slope at β =0.95 of graph, capcity per resource vs β ^-1, as a function of SNR for different frame types and p From Figure 12 you can see our hypothesis was correct. The capacity per resource will never have a maximum point at (the slope is always lower than 1). However, if we neglect the identity matrix, which is in fact examining the practical capacity as defined in Equation , we see it is possible but depends on the SNR. As an example, you can view Figure 13. 3 Figure 13 - example of maximum point at β≠ Practical capacity
Let us examine the practical capacity rate performance of the different frames. We will start by looking on the LGM first.
Figure - LGM performance for different frame types and p VS β ^-1 From Figure we can see that the eigenvalues of ETFs and random frames remain relatively steady even for = . The theoretical calculation, however, equals − at = because apparently the possibility of getting a zero eigenvalues exists. Only a slight movement from = ensures we get eigenvalues larger than zero. The case for LPF and sparse frames is totally different. It’s clear that the eigenvalues of the frames grow smaller rapidly and are significantly affected by the size of . This implies the practical capacity's maximum point for these two types of frames will be achieved at smaller than for ETF and random frames. Note that Figure can also represent the practical capacity per user at SNR=1dB as the SNR only adds a constant to all graphs. For example, you can look at Figure 15 and see its identical to Figure with an added constant. 5 Figure 15 – practical capacity rate per user for differnet frame type VS β ^-1 , for SNR=30dB Now, examining the practical capacity per resource in Figure , we can see it coincides with our previous conclusions. The optimal point for ETFs and random frames is indeed achieved at much higher than LPFs and sparse frames. Figure – practical capacity per resource for different frame types VS β^ -1, for different SNRs SNR effect
Another factor to take into consideration is the SNR. Larger SNRs drive the optimal point closer to 1 for all frames. For ETFs and random frames the drift towards 1 is very quick, and even when the optimum is far from 1, the capacity difference is neglectable. Meaning the optimal point operating point will always be a nudge from 1. For the other frames the drift is slower, and the optimal operating point will be for some as can be seen in Figure 17. 6 Figure 17 – practical capacity rate's optimal β drift toward 1 with SNR for different frame types Looking at the optimal for capacity per resource, Figure , we can see the effect of the identity matrix which canceled the fading towards 1 causing the optimal to be always a nudge from 1 for all frame types and all SNR. Meaning the SNR has no effect on the capacity per resource's optimal operating point. Figure - capacity's optimal β drift toward 1 with SNR for different frame types Discussion and Future Work
We started this paper by briefly examining the special case of fully active NOMA system ( p = ). We saw the superiority of sparse frames over random ones but that the largest capacity was achieved by unit norm tight frames of any kind. We proceeded to the general case of partially active system were only part of the users are active simultaneously. We asked ourselves, given a constant p ,what are the best , pair and frame type we can choose to improve our system's performance? The performance analysis was divided into two cases – (1) Capacity analysis and (2) practical capacity analysis, a realist maximal rate achieved by simple coding schemes. The latter helped understand the influence of the eigenvalues and the SNR on the system. For the capacity analysis we saw there is a constant tradeoff between system efficiency and user capacity when choosing the best , pair. Since the user capacity reaches a plateau and can’t be improved significantly, the best choice for would be the one maximizing the spectral efficiency which is a nudge from 1 or even 1 for large SNRs. Regarding the best frame type, the answer depends on p : 1. For small p ( p ) random frames give good results and even the ETF advantage is neglectable. So it all depends on generation convenience. 2. For medium p ( p ) the ETF's superiority is dominant and is the obvious choise. 3. For large p ( p ) , including the special case of fully active, there is almost no difference between the performance of an ETF and a LPF . So, the preferred choice would be a LPF in order to reduce system complexity. Analizing the practical capacicty helped us visulaize the affect of the eigenvalues and the SNR . We saw, for all frame types, that the user capacity goes to − at = due to the probability of a zeroed eigenvalue. However, while the eigenvalues of ETFs and random frames recuperate rapidly, the eigenvalues of LPFs and sparse frames remain small (and so does the user capacity) for a large range of s. This is the reason why the spectral efficiency's optimal is: 1. a nudge from 1 for ETFs and random frames. 2. Depends on the SNR for LPFs and sparse frames, grows closer to 1 with the increase of SNR. when choosing the preferred frame type the choice is between ETF and random frame for two reasons: 1.
They achieve larger practical capacity than LPF and sparse frame. 2. their operating point is not dependent on the SNR. ETF always achieves the best results, but its advantage diminishes with the decrease of p . In conclusion setting the system so that is a nudge from 1 is the optimal choice. If sufficiently complex coding schemes can be employed in order to reach capacity, random frames, ETFs or LPFs can be used for resource-user mapping, depending on the user 8 participance ratio. Further work can be dedicated to finding a better UNTF that will reduce the advantage of ETF at medium size p . In addition, more types of difference sets can be explored to broaden the range of ETF’s dimensions . 9 References Random subsets of structured deterministic frames have MANOVA spectra.
Haikin, Marina, Zamir, Ram and Gavish, Matan.
26, 2017, Proceedings of the National Academy of Sciences of the United States of America, Vol. 114, p. 201700203. Sparse NOMA: A Closed-Form Characterization.
Zaidel, Benjamin M., Shental, Ori and Shamai, Shlomo.
Massively Concurrent Non-Orthogonal Multiple Access for 5G Networks and Beyond.
Stoica, Razvan-Andrei, et al.
Frame Moments and Welch Bound with Erasures.
Marina Haikin, Ram Zamir, Matan Gavish.
Lower bounds on the maximum cross correlation of signals (Corresp.).
Welch, L.
3, s.l. : IEEE, 1974, Vol. 20. 6.
Achieving the Welch bound with difference sets.
P Xia, S Zhou, GB Giannakis.
Steiner equiangular tight frames.
Matthew Fickus, Dustin G. Mixon, Janet C. Tremain. – Verdú, Antonia M. Tulino and Sergio.
Random Matrix Theory and Wireless Communications. Appendixes
Matlab code – sparse matrix generation function [F] = create_zaidel_matrix(M,betta,d) tries = 5; N = round(betta*M); %num of users
F = zeros(M,N); ms = repmat((1:M),1,round(betta*d)); ns = repmat((1:N),1,d); fail=1; for i = 1:N*d done_before = 1; rand_angle = 2*pi*rand; rand_number = cos(rand_angle)+1i*sin(rand_angle); for t = 1:tries m_idx = randi(length(ms)); n_idx = randi(length(ns)); m = ms(m_idx); n = ns(n_idx); if F(m,n)==0 fail=0; break; end end if fail == 1
F = NaN; break end
F(m,n) = rand_number; ms(m_idx) = []; ns(n_idx) = []; end end
Matlab code – LPF generation function [F] = generate_LPF(M,N)
F = dftmtx(N);
F = F(1:M,:); h = F(:,1);
F = sqrt(1/abs(h'*h))*F; check_utf = abs(F'*F); if all(all(F*F' - N/M*eye(M)<0.0001)) && all(diag(check_utf)-1<0.0001) fprintf('Matrix F is UTF\n'); end
Python code - Steiner ETF construction import numpy as np import itertools from concurrent import futures def main(): M = 70 beta = 3.3 N = beta * M k = 3 v = 21 r = 10 b = M elements = list(itertools.combinations(range(v),k)) A = np.zeros((int(b), v)) elements = random.sample(elements, len(elements)) answer = set_block(A.copy(), 0, elements, v-1,r) print(answer) current_col = 0 for col in range(v): rows = answer[col] if rows == ['OK']: continue if col == 0: block_start = 0 else: block_start = np.argwhere(A[:, col - 1] == 1)[-1][0] + 1 for i in range(len(rows)): row = rows[i] for j in row: A[block_start + i][j] = 1 print(A) np.savetxt('matrix.csv', A, delimiter=',') def set_block(A,col,elements,max_col,r): combin = [x for x in elements if x[0] == col] if not combin: if col == max_col: return [['OK']] elif r - np.sum(A[:, col]) == 0: block_answer = set_block(A.copy(), col + 1, elements.copy(), max_col, r) return [['OK']]+block_answer [elements.remove(x) for x in combin] for i in range(len(combin)): if (col == 2) and (i <= 278): continue if col<=3: print([col,i]) temp_A = A.copy() temp_elements = elements.copy() answer = set_row(combin.copy(), row=i, deep=0, max_deep=r-np.sum(A[:, col])-1) if answer: if col == max_col: return answer else: if col == 0: block_start = 0 else: block_start = np.argwhere(temp_A[:, col - 1] == 1)[-1][0]+1 for a in range(len(answer)): element = answer[a] two_comb = list(itertools.combinations(element, 2)) for j in element: temp_A[block_start+a][j] = 1 for j in range(len(temp_elements) - 1, -1, -1): Python code - Steiner ETF construction using parallel computing import numpy as np import itertools from concurrent import futures def main(): M = 70 beta = 3.3 N = beta * M k = 3 v = 21 r = 10 b = M elements = list(itertools.combinations(range(v),k)) A = np.zeros((int(b), v)) elements = random.sample(elements, len(elements)) answer = set_block(A.copy(), 0, elements, v-1,r) print(answer) current_col = 0 for col in range(v): rows = answer[col] if rows == ['OK']: continue if col == 0: block_start = 0 else: block_start = np.argwhere(A[:, col - 1] == 1)[-1][0] + 1 for i in range(len(rows)): row = rows[i] for j in row: A[block_start + i][j] = 1 print(A) np.savetxt('matrix.csv', A, delimiter=',') def set_block(A,col,elements,max_col,r): combin = [(x,y,z) for (x,y,z) in elements if x == col] if not combin: if col == max_col: return [['OK']] elif r - np.sum(A[:, col]) == 0: block_answer = set_block(A.copy(), col + 1, elements.copy(), max_col, r) return [['OK']]+block_answer [elements.remove(x) for x in combin] if col == 4: with futures.ProcessPoolExecutor() as pool: for response in list(pool.map(content, range(len(combin)), itertools.repeat(col), itertools.repeat(A),itertools.repeat(elements),itertools.repeat(combin),itertools.repeat(r),itertools.repeat(max_col))): if response: return response else: for i in range(len(combin)): response = content(i, col, A,elements,combin,r,max_col) if response: return response return [] def content(i,col,A,elements,combin,r,max_col): if col <= 4: print([col, i]) temp_A = A.copy() temp_elements = elements.copy() answer = set_row(combin.copy(), row=i, deep=0, max_deep=r - np.sum(A[:, col]) - 1) if answer: if col == max_col: return answer else: if col == 0: block_start = 0 else: block_start = np.argwhere(temp_A[:, col - 1] == 1)[-1][0] + 1 for a in range(len(answer)): element = answer[a] two_comb = list(itertools.combinations(element, 2)) for j in element: temp_A[block_start + a][j] = 1 for j in range(len(temp_elements) - 1, -1, -1): if __name__ == '__main__': main() Matlab code -
Gaussian i.i.d. Frame construction function [F] = generate_Gau_iid(M,N)
F = normrnd(0,1/M,M,N); norm = 1./sqrt(diag(abs(F'*F))); norm = repmat(norm.',M,1);
F = norm.*F; check_utf = abs(F'*F); if all(diag(check_utf)-1<0.0001) fprintf('Matrix F is normalized\n'); endend