Patent Publication Number: US-11641269-B2

Title: Modulation-agnostic transformations using unitary braid divisional multiplexing (UBDM)

Description:
STATEMENT REGARDING FEDERAL GOVERNMENT INTEREST 
     This United States Government holds a nonexclusive, irrevocable, royalty-free license in the invention with power to grant licenses for all United States Government purposes. 
    
    
     CROSS-REFERENCE TO RELATED APPLICATIONS 
     This application is related to U.S. Non-Provisional patent application Ser. No. 16/416,144, filed on May 17, 2019 and titled “COMMUNICATION SYSTEM AND METHODS USING MULTIPLE-IN-MULTIPLE-OUT (MIMO) ANTENNAS WITHIN UNITARY BRAID DIVISIONAL MULTIPLEXING (UBDM)”; and to U.S. Non-Provisional patent application Ser. No. 16/459,245, filed on Jul. 1, 2019 and titled “SYSTEMS, METHODS AND APPARATUS FOR SECURE AND EFFICIENT WIRELESS COMMUNICATION OF SIGNALS USING A GENERALIZED APPROACH WITHIN UNITARY BRAID DIVISION MULTIPLEXING”; and to U.S. Non-Provisional patent application Ser. No. 16/459,262, filed on Jul. 1, 2019 and titled “COMMUNICATION SYSTEM AND METHOD USING LAYERED CONSTRUCTION OF ARBITRARY UNITARY MATRICES,” the disclosures of each of which are herein incorporated by reference in their entireties for all purposes. 
     TECHNICAL FIELD 
     The present invention relates generally to data communication, and more specifically to techniques for enhancing security of data communications using unitary braid divisional multiplexing (UBDM). 
     BACKGROUND 
     Wireless communication systems are widely deployed to provide various types of communication services such as voice, packet data, and so on. These systems may utilize a modulation technique capable of providing high performance for some wireless environments, for example by partitioning the overall system bandwidth into a number of subbands (e.g., (Ns) orthogonal subbands), which are also commonly referred to as subcarriers, tones, bins, and frequency subchannels. In multiple access communications, multiple user devices transmit signals over a single communications channel to a receiver. These signals are superimposed, forming a combined signal that propagates over that channel. The receiver then performs a separation operation on the combined signal to recover one or more individual signals from the combined signal. For example, each user device may be a cell phone belonging to a different user and the receiver may be a cell tower. By separating signals transmitted by different user devices, the different user devices may share the same communications channel without interference. 
     A transmitter may transmit different symbols by varying a state of a carrier or subcarrier, such as by varying an amplitude, phase and/or frequency of the carrier. Each symbol may represent one or more bits. These symbols can each be mapped to a discrete value in the complex plane, thus producing Quadrature Amplitude Modulation, or by assigning each symbol to a discrete frequency, producing Frequency Shift Keying. The symbols are then sampled at the Nyquist rate, which is at least twice the symbol transmission rate. The resulting signal is converted to analog through a digital to analog converter, and then translated up to the carrier frequency for transmission. When different user devices send symbols at the same time over the communications channel, the sine waves represented by those symbols are superimposed to form a combined signal that is received at the receiver. 
     SUMMARY 
     In some embodiments, a method for implementing a fast UBDM transform includes receiving a first vector (an input vector) via a processor, and partitioning the first vector to produce a magnitude vector and a sign vector. A second vector, including a modified magnitude vector and a modified sign vector, is generated by: applying a permutation to the magnitude vector to produce the modified magnitude vector, converting the sign vector, based on an algorithm, into an intermediate sign vector, and applying a plurality of nonlinear layers to the intermediate sign vector, to produce the modified sign vector. The converting the sign vector is optionally based on an initialization vector. Each nonlinear layer from the plurality of nonlinear layers includes at least one of, or any combination of, a permutation, an S-box transformation, a diffusive linear operation, or an Xor operation. A plurality of linear layers is applied to the second vector to produce a third vector, the third vector being a transformed version of the first vector. A first signal representing the third vector is sent to at least one transmitter for transmission of a second signal representing the transformed data vector from the at least one transmitter to at least one receiver. In some implementations, the permutation applied to the magnitude vector does not reduce a total power of the first vector. 
     In some embodiments, a method for implementing a fast UBDM transform includes receiving, via a processor, an input vector including a plurality of complex numbers. A transformed vector is generated, based on the input vector and via the processor, by: applying a permutation to a magnitude vector associated with the input vector, to produce a modified magnitude vector, applying an algorithm (e.g., including an Xor operation) and a plurality of nonlinear layers to a sign vector associated with the input vector, to produce a modified sign vector, the modified magnitude vector and the modified sign vector defining an intermediate vector, and applying a plurality of linear layers to the intermediate vector to produce the transformed vector. The method also includes sending a signal representing the transformed vector to at least one transmitter for transmission of a second signal representing the transformed vector from the at least one transmitter to at least one receiver. In some implementations, the permutation applied to the magnitude vector does not reduce a total power of the first, input vector. 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         FIG.  1    is a block diagram illustrating an example electronic communications system within an electronic environment in which improved techniques described herein may be performed. 
         FIG.  2    is a block diagram illustrating a process flow for encoding and decoding a signal, according to an embodiment. 
         FIG.  3    is a diagram illustrating a system for encoding and decoding a signal, according to an embodiment. 
         FIG.  4    is a flowchart illustrating an example method for modulating data using a non-linear transformation, according to an embodiment. 
         FIG.  5    is a flowchart illustrating an example method for implementing a fast UBDM transform, according to an embodiment. 
         FIG.  6    is a flowchart illustrating an example method for implementing a fast UBDM transform, according to an embodiment. 
     
    
    
     DETAILED DESCRIPTION 
     When linear transformations are applied to data as part of an encoding (e.g., “pre-coding”) or modulation process prior to transmission via a network, the transmitted data can be susceptible to deciphering by eavesdroppers who may be able to determine the linear transformations based on a small number of “plain/cipher” sets (e.g., pairs) and using, for example, a single matrix inversion. As such, systems and methods employing linear transformations can be improved by the non-linearization of pre-transmission data. Although known mechanisms exist for applying nonlinear operations on complex numbers in general, and notwithstanding the data security risks associated with linear transformations, the application of such mechanisms in the context of data modulation is not believed to have previously been successfully performed, for example because of the various constraints and considerations commonly associated with data modulation. For example, during modulation, the power of the signal being transmitted can be reduced, and noise and distortion can be amplified. Non-unitary and non-linear operations can amplify and distort signals, thereby increasing the Bit Error Rate (BER). Non-linear transformations are typically not isometric, and therefore also amplify noise and increase BER to undesirable levels. By contrast, unitary transformations preserve signal power and are isomorphic/isometric, and thus are used ubiquitously in signals without taking into account security considerations. Some known cryptologics include a non-linear component that can block a linear attack by an eavesdropper. Because such cryptologics operate on bits (i.e., bit-level security) rather than on symbols, however, noise is not of concern. 
     Techniques are provided herein for modifying complex baseband symbols in a non-linear manner, to enhance security of orthogonal frequency-division multiplexing (OFDM) systems. In some embodiments, a method of encoding data includes identifying multiple complex number sets (e.g., pairs) of an input data vector and generating a transformed data vector by applying a non-linear transformation to each complex number set from the multiple complex number sets. The non-linear transformation includes modifying a phase of a first complex number from each complex number set. The phase modification is based on a value associated with a second complex number from each complex number set. A signal representing the transformed data vector is sent to multiple transmitters for transmission of a signal representing the transformed data vector from the multiple transmitters to multiple receivers. A signal representing the non-linear transformation is sent to a second compute device for transmission of the non-linear transformation to the multiple receivers prior to transmission of the signal representing the transformed data vector from the multiple transmitters to the multiple receivers, for recovery of the data vector at the multiple receivers. 
     As used herein, a “transmitter” (or “signal transmitter”) refers to any collection of components that are used in the transmission of signals, including any combination of, but limited to, one or more: antennas, amplifiers, cables, digital-to-analog converters, filters, up-converters, processors (e.g., for reading bits and/or mapping of bits to a baseband), etc. Similarly, as used herein, a “receiver” (or “signal receiver”) refers to any collection of components that are used in receiving signals, including any combination of, but limited to, one or more: antennas, amplifiers, cables, analog-to-digital converters, filters, down-converters, processors, etc. 
     Some embodiments of the present disclosure include systems and methods that achieve non-linearization of pre-transmission data symbols as part of the modulation process, for establishing data privacy at the physical layer without amplifying noise. Non-linear transformations (or “transforms”) set forth herein include non-linear transformations that do not amplify noise, or that introduce a minimal amount of amplification to noise. The non-linear transformation can be applied to input data (e.g., data vectors or symbols derived therefrom) once or several times, optionally interleaved with other transformations (linear or otherwise) any number of times. 
       FIG.  1    is a diagram that illustrates an example system  100  in which improved techniques of transmitting wireless communications are performed. The system  100  includes a signal transmitter  120  and a signal receiver  150 . It should be appreciated, however, that there may be other signal transmitters not pictured within the environment. 
     The signal transmitter  120  is configured to prepare signals for transmission to the signal receiver  150  and to transmit the prepared signals to the signal receiver  150 . The signal transmitter  120  includes processing circuitry units  124 , memory  126 , and transmission circuitry unit  128 . The set of processing units  124  include one or more processing chips and/or assemblies. The memory  126  includes both volatile memory (e.g., RAM) and non-volatile memory, such as one or more ROMs, disk drives, solid state drives, and the like. The set of processing units  124  and the memory  126  together form control circuitry, which is configured and arranged to carry out various methods and functions as described herein. The transmission circuitry  128  is configured to transmit signals in the form of radio-frequency energy to the receiver. 
     In some embodiments, one or more of the components of the signal transmitter  120  can be, or can include, processors (e.g., processing units  124 ) configured to process instructions stored in the memory  126 . Examples of such instructions as depicted in  FIG.  1    include an initial vector generation manager  130  and a sync signal generation manager  146 . Further, as illustrated in  FIG.  1   , the memory  126  is configured to store various data, including initial vectors  132 , channel indices  136 , signals  140 , and sync signals  148 . 
     Fast Unitary Transformations 
     Methods and systems described above usually involve a matrix operation on a vector. If the length of the vector is N and the size of the matrix is N×N (e.g., when the matrix is a unitary matrix), then the matrix operation on the vector involves O(N 2 ) multiplications. Accordingly, as N increases, the computational burden on the telecommunication system can be prohibitive. 
     In some embodiments, some fast unitary transformations can be employed to reduce the calculation complexity. For example, the matrix operation on the vector can be achieved using Fourier matrix, Walsh-Hadamard matrix, Haar matrix, Slant matrix, certain types of Toeplitz matrix, and certain types of circulant matrices that can be operated on a vector in a fast complexity class. These types of matrices, however, only form a limited class of transformations and therefore the resulting level of security may not be satisfactory. 
     To address the complexity issues while maintaining the security of the communication, systems and methods described herein employ an approach to build an arbitrary unitary matrix up from smaller matrices. In this approach, unitary matrices are built up in layers. Each layer includes two operations. The first operation is a permutation and the second operation is a direct sum of U(2) matrices. Permutation matrices are unitary matrices that do not require any floating point operations and therefore are computationally free, i.e., with O(1) complexity. U(2) matrices are matrices where most of the values are 0, except the 2×2 blocks along the diagonal (also referred to as block-U(2) matrices). These block-U(2) matrices involve only 4×N/2=2×N multiplications. As a result, a layer including a block-U(2) involves 2×N multiplications for the block-U(2) and no multiplications for the permutation. In other words, one layer during construction of a unitary matrix has complexity O(N). 
     The total complexity of constructing a unitary matrix is the product of the number of layers and O(N) that is the complexity of each layer. In some embodiments, the total number of layers can be log(N), and the total complexity of all of the layers is therefore O(N×log(N)), which is equivalent to the complexity of a standard OFDM. In addition, log(N) layers of block-U(2) and permutation matrices can produce a dense unitary. While the space of fast unitary matrices is not as large as the full space of unitary matrices, it can still be sufficiently large to make an attack by an eavesdropper prohibitive (see more details below with reference to  FIG.  9   ). 
     In some embodiments, the approach described herein can employ block-U(m) matrices to build unitary matrices, where m is a positive integer (e.g., m=3, 4, 5, etc.). In some embodiments, matrices having different sizes can also be used within a single layer when constructing a unitary matrix. In some embodiments, different layers can use matrices having different sizes, e.g., a first layer uses block-U(m) matrices and a second layer uses block-U(l) matrices, where m is different from 1. For example, if N=8, a set of four 2×2 block-U(2) matrices can be used in the first layer, followed by a permutation. Then two U(3) matrices and a single U(2) matrix can be used in the second layer, followed by another permutation. The third layer can include a block-U(2) matrix, a block-U(4) matrix, and then another block-U(2) matrix, followed by a third permutation. 
     In some embodiments, certain types of fast unitary matrices can also be written in terms of layers, each of which includes a permutation and a direct sum of blocks of smaller matrices. These types of matrices include, for example, Fourier matrices, Walsh-Hadamard matrices, Haar matrices, Slant matrices, and Toeplitz matrices. In some embodiments, the unitary matrix that can be constructed using the layered approach includes any matrix that is not a direct sum of discrete Fourier matrices. 
     Security Issues with Linear Transformations in Modulation 
     To illustrate the security vulnerabilities associated with data modulation using linear transformations, suppose that Alice and Bob are only applying a linear unitary matrix A to a data symbol  b  to get  s = Ab  at the transmitter, and then applying A †  (i.e., the inverse of matrix A) to  s  at the receiver to get A †   s =A †   Ab = b . In this case, suppose that Eve is able to collect a set of N linearly independent values of  s , denoted  s   1 ,  s   2 , . . . ,  s   N . If Eve knows the corresponding untransformcd bauds  b   1 , . . . ,  b   N , she can arrange the untransformcd bauds into a matrix B=( b   1 , . . . ,  b   N ), and the transformed bauds into the corresponding matrix S=( s   1 , . . . ,  s   N ). The equation linking B and S is then
 
 S=AB   (18)
 
As such, and because the bauds are assumed to be linearly independent and A is assumed to be unitary, S will be full rank (i.e., all rows and columns are linearly independent), and Eve can readily invert it, getting
 
 A=BS   −t   (19)
 
This gives Eve the entire matrix A, and as such, the security of the data transmission has been breached.
 
Non-Linear Transformations in Modulation
 
     The foregoing example illustrates the security vulnerability that can exist when a linear transformation used for data modulation. The following sections describe embodiments for non-linearizing transformations during data modulation to improve security of data transmissions while avoiding drawbacks that are typically associated with non-linear operations. For example, as discussed above, non-linear transformations can amplify and/or distort a signal, thereby amplifying the noise, decreasing signal-to-noise ratio (SNR), and/or increasing the Bit Error Rate (BER). Some embodiments set forth herein accomplish a disruption of the linearity (i.e., a non-linearization) without amplifying (or minimally amplifying) the noise, in a way that may allow the system designer to tune the degree of non-linearity. Non-linear transformations described herein may not increase the total power of the signal, and are invertible, and thus permit data recovery at a receiver. The non-linear transformations can be applied to input data (e.g., data vectors or symbols derived therefrom) once or several times, optionally interleaved with other transformations (linear or otherwise) any number of times, prior to transmission of the transformed. For example, there may be 5 layers of a “block U(2)” matrix with a non-linear transformation (as set forth herein) and a permutation. 
       FIG.  2    is a block diagram illustrating a process flow for encoding and decoding a signal using a non-linear transformation, according to an embodiment. During the encoding and decoding process  200 , an input data vector “X” is input at  202  to a compute device. Anon-linear transformation (which is, optionally, a norm-preserving transformation) is applied via the compute device at  210  to the input data vector X to produce a transformed vector. The transformed vector is sent, at  212 , to one or more transmitters for wireless transmission  220 . One or more signals representing the transformed vector is sent to one more receivers at  222 , and once received at the one or more receivers, the transformed vector is decoded/demodulated at  230  based on the non-linear transformation to reconstruct the input data vector at  232  (output “Y”). As indicated by the dashed line in  FIG.  2   , a representation of the non-linear transformation may have been transmitted from the compute device to the one or more receivers (e.g., prior to, concurrently with, in parallel with, overlapping in time with, or after transmission of the one or more signals representing the transformed vector is sent to one more receivers at  222 ). 
     In some embodiments, the non-linear transformation includes applying a first non-linear transformation and a second non-linear transformation prior to sending the signal representing the transformed data vector to the plurality of transmitters. The first and second non-linear transformations can be applied to a common collection or subset of complex number sets, or each can be applied to a different collection or subset of complex number sets. For an example of the latter case, suppose an input data vector has a length of 4, and includes components (i.e., complex numbers) 1, 2, 3, and 4. Now suppose that prior to the first non-linear transformation, components 1 and 2 are paired as one set, and components 3 and 4 are paired as another set. The first non-linear transformation is then applied to the (1,2) set and to the (3,4) set, for example in parallel or overlapping in time. Next, another collection of sets is identified, in which components 1 and 3 are paired as a first set, and components 2 and 4 are paired for the second set. The second non-linear transformation is then applied to the (1,3) set and to the (2,4) set, for example in parallel or overlapping in time. Note that, in some embodiments, although the first non-linear transformation can be applied to the (1,2) set and to the (3,4) set in parallel and the second non-linear transformation can be applied to the (1,3) set and to the (2,4) set in parallel, the first and second non-linear transformations are not performed in parallel, since the input to the second non-linear transformation is the output from the first nonlinear transformation. 
     Example Nonlinear Operations 
     In some embodiments, a nonlinear operation Q is applied q times in the first part of a fast transform. Each Q i  has a length N vector associated with it, denoted  w   i , and there is a total of q such vectors. The values in  w   i  can be referred to as “activators” for the full nonlinear transform Q. Each component of  w   i  is a 2-bit value. As such, in all, there are 2N bits in each  w   i . 
     The action of Q i  (which depends on  w   i ) is pairwise, on adjacent values of  b  (i.e., components 1 and 2, then components 3 and 4, etc.). The action can be illustrated with reference to a single 2 component block. Q can include a modification of the second component of each doublet of the vector if and only if some condition on the values of  w   i  and b 1  are met, in a way that depends on what those values are. The following is example pseudo-code for the action of Q on a single doublet. The input is the two vector components b 1  and b 2  (which reside in the constellation C) and the two 2-bit values w 1  (with bits w 11  and w 12 ) and w 2  (with bits w 21  and w 22 ). 
     
       
         
           
               
             
               
                   
               
             
            
               
                 if w 11  == 0 then 
               
               
                  if (−1) w12  == Sign (Re(b 1 )) then 
               
               
                   if (w 21 , w 22 ) == (0, 0) || (w 21 , w 22 ) == (1, 1) then 
               
               
                    b 2  ← −b 2   
               
               
                   end if 
               
               
                   if (w 21 , w 22 ) == (0, 1) then 
               
               
                    b 2  ←, b 2   *   
               
               
                   end if 
               
               
                   if (w 21 , w 22 ) == (1, 0) then 
               
               
                    b 2  ← −b 2   *   
               
               
                   end if 
               
               
                  end if 
               
               
                 end if 
               
               
                 if w 11  == 1 then 
               
               
                  if ( −1) w12  == Sign (Im(b 1 )) then 
               
               
                   if ((w 21 , w 22 ) == (0, 0) || (w 21 , w 22 ) == (1, 1)) then 
               
               
                    b 2  ← −b 2   
               
               
                   end if 
               
               
                   if (w 21 , w 22 ) == (0, 1) then 
               
               
                    b 2  ← b 2   * &#39; 
               
               
                   end if 
               
               
                   if (w 21 , w 22 ) == (1, 0) then 
               
               
                    b2 ← −b 2   *   
               
               
                   end if 
               
               
                  end if 
               
               
                 end if 
               
               
                   
               
            
           
         
       
     
     The function Sign(x) is a function that returns +1 when x&gt;0 and −1 when x&lt;0. As an example, consider a case in which w 1  and w 2  are (1; 0) and (1; 1), respectively, and b 1 =1+i and b 2 =−1+i. Since w 11 =1, the imaginary part of b 1  is considered. The sign of the imaginary part of b 1  is Sign (Im(b 1 ))=Sign (Im(1+i))=Sign(+1)=+1. The value (−1) w12 =(−1) 0 =+1. As such, it is the case that (−1) w12 ==Sign (Im(b 1 )). Because w 2 =(1, 1), b 2   −b 2  and the action of Q on this doublet is: 
     
       
         
           
               
               
               
               
               
               
               
               
             
               
                   
               
             
            
               
                   
                 1 + i  
                   
                 → 
                   
                 1 + i 
                   
                 (0.1.1) 
               
               
                  {open oversize parenthesis}  
                   
                  {close oversize parenthesis}  
                   
                  {open oversize parenthesis}  
                   
                  {close oversize parenthesis}  
                   
               
               
                   
                 −1 + i  
                   
                   
                   
                 1 − i 
               
               
                   
               
            
           
         
       
     
     Note that the first (top) component is unchanged. The foregoing is performed for each doublet of the vector, and such operations collectively constitute a single application of Q. The permutations are included so that different components act as “control gates” for other components at each of the q layers. Note that the action of Q is unitary, though highly nonlinear. 
     In some embodiments, generating the transformed data vector also includes performing a linear transformation or a discrete Fourier transform after applying the non-linear transformation. Alternatively or in addition, the one or more receivers that receive the one or more signals representing the transformed vector includes a plurality of antenna arrays, and the receiver(s) and the transmitter(s) can be configured to perform Multiple Input Multiple Output (MIMO) operations. 
       FIG.  3    is a diagram illustrating a system for encoding and decoding a signal (e.g., for implementing the process  200  of  FIG.  2   ), according to an embodiment. The system  300  includes one or more transmitters (“Tx”)  310  each including a processor  312  and multiple antennas  314   a  through  314   d . The transmitter  310  is communicatively coupled, via a wireless communications network  320 , to one or more receivers (“Ty”)  330  each including a processor  332  and multiple antennas  324   a  through  324   c . An input data vector X is received at the system at  302  and is transformed, via a non-linear transformation, into a transformed data vector that is transmitted by the transmitter  310 , via one or more of the antennas  314   a  through  314   d  the network  320 , to the receiver(s)  330 . The transformed vector is received at the receiver(s)  330 , via one or more of the antennas  324   a  through  324   c , and demodulated based on the non-linear transformation to produce the recovered data vector Y at  342 . Each of the antennas  314   a  through  314   d  can transmit signals to multiple antennas from the antennas  324   a  through  324   c . In other words, the antennas  314   a  through  314   d  of the receiver  310  and the antennas  324   a  through  324   d  of the receiver  330  can be configured to perform Multiple Input Multiple Output (MIMO) operations as follows: antenna  314   a  of transmitter  310  can send signals via the wireless communications network  320  to one of, a subset of, or all of antennas  324   a ,  324   b , and  324   c  of the receiver  330  (as signals  322   a ,  322   b  and  322   c , respectively). Similarly, antenna  314   b  of transmitter  310  can send signals via the wireless communications network  320  to one of, a subset of, or all of antennas  324   a ,  324   b , and  324   c  of the receiver  330  as signals  322   d ,  322   e  and  322   f , respectively), and antenna  314   c  of transmitter  310  can send signals via the wireless communications network  320  to one of, a subset of, or all of antennas  324   a ,  324   b , and  324   c  of the receiver  330  as signals  322   g ,  322   h  and  322   i , respectively). 
       FIG.  4    is a flowchart illustrating an example method for modulating data using a non-linear transformation, according to an embodiment. As shown in  FIG.  4   , the method  400  includes identifying, at  410  and via a processor of a first compute device, multiple complex number sets of an input data vector. The input data vector includes multiple complex numbers. At  420 , a transformed data vector is generated by applying, to each subset of complex number sets from the multiple complex number sets, a non-linear transformation. The non-linear transformation includes modifying a phase of a first complex number from that complex number set based on a value associated with a second complex number from that complex number set. A signal representing the transformed data vector is sent, at  830 , to multiple transmitters for transmission of a signal representing the transformed data vector from the multiple transmitters to multiple receivers. At  440 , a signal representing the non-linear transformation is sent to a second compute device for transmission of the non-linear transformation to the multiple receivers prior to, concurrently with, overlapping in time with, or after transmission of the signal representing the transformed data vector to the multiple receivers, for recovery of the data vector at the plurality of receivers. 
     In some embodiments, modifying the phase of the first complex number from the complex number set is also based on a predetermined factor, and the method  400  also includes sending a signal representing the predetermined factor to the plurality of receivers prior to, concurrently with, overlapping in time with, or after transmission of the signal representing the transformed data vector from the plurality of transmitters to the plurality of receivers, for recovery of the data vector at the plurality of receivers. 
     In some embodiments, an input data vector includes multiple complex numbers that are partitioned or broken up into their “norm” (or “magnitude”) and phase components. For example, each complex number z can be written as:
 
 z=r e   i*x ,
 
where r is a positive real number and x is a real number within [0, 2pi).
 
     The multiple complex numbers are partitioned or broken up into complex number sets (e.g., multiple complex number sets are detected or selected), and differences between the two norms of each complex number set are calculated. If r1 is the norm of one of the two complex numbers and r2 is the norm of the other, the difference is calculated as r1−r2 or r2−r1. The difference is then raised to a power p, to obtain an intermediate value (r1−r2)*p or (r2−r1)*p. The intermediate value is then multiplied by a predetermined constant, R, to obtain the value: R*(r1−r2)*p or R*(r2−r1)*p. This value is then used to define an angle by which the phase of the original complex number (z1 or z2) having the smaller norm is rotated/adjusted. 
     As an example, given a set of complex numbers as follows:
 
 z 1= r 1* e   {i x1} 
 
 z 2= r 2* e   {i x2} 
 
     Assuming that r2&lt;r1, the phase of z2 is adjusted while z1 remains unchanged, as follows:
 
 z 1= r 1* e   {i x1} 
 
 z 2= r 2* e   {i x2}*   e   {iR*(r1−r2){circumflex over ( )}p} 
 
     In other words, the complex number having the smaller magnitude is rotated in the complex plane by an angle proportional to a power of the difference between the magnitudes of the complex numbers of the set (i.e., a non-linear transformation). Simulation has shown that for any N (N being the number of subcarriers) and any underlying constellation, there is a value of p and R that render any attempt by an eavesdropper at a linear attack impossible, while having a negligible impact on the BER (at most, less than half a dB of cluster variance for realistic SNRs). A “constellation” (or constellation diagram) is a representation of a signal modulated by a digital modulation scheme. 
     In some embodiments, the values of R and p vary for each set of symbols in each baud. For example, R may be a function of which “layer” (e.g., in the sense described above, where “layers” are made up of block-U(2)s and permutations, discussed above) and/or a function of which set of symbols is being operated on. 
     In some embodiments, a non-linear transformation can be performed at any stage of precoding or pre-transmission operations and/or on any collection of sets of complex numbers in the input data vector. For example, the non-linear transformation can be performed one or more of: once at the beginning of precoding or pre-transmission operations, once at the end of precoding or pre-transmission operations, between each block-U(2) and permutation (i.e., after the block-U(2) and before the permutation), etc. The non-linear transformation can be interleaved with any number and combination of other precoding operations, whether linear or non-linear. In some embodiments the non-linear transformation is applied to all complex number sets of an input vector. In other words, each complex number is combined with one other complex number, making a total of N/2 sets. In other embodiments, the non-linear transformation is only applied to a subset of the complex number sets of an input vector and not to other complex number sets of the input vector. 
     In some embodiments, the non-linear transformation is performed as follows. Take two components of the total (length-N) baud. Both components may be complex numbers, so they can be written as: 
     
       
         
           
               
               
               
               
               
               
               
               
             
               
                   
               
             
            
               
                   
                 z 1   
                   
                 = 
                   
                 r 1 e iθ     1     
                   
                 (20) 
               
               
                  {open oversize parenthesis}  
                   
                  {close oversize parenthesis}  
                   
                  {open oversize parenthesis}  
                   
                  {close oversize parenthesis}  
                   
               
               
                   
                 z 2   
                   
                   
                   
                 r 2 e iθ     2     
               
               
                   
               
            
           
         
       
     
     A single 2-vector is presented above for the sake of discussion, however other vector lengths/sizes can also be used (e.g., single 3-vector, single 4-vector, multiple vectors, etc.). The following operation can be performed on any two components of the vector, and the two components need not necessarily be adjacent to each other. In some implementations, several layers of “fast UBDM” layers of block-U(2)s and permutations are applied first, followed by applying the non-linear transformation to each set of vectors (e.g., adjacent or “side-by-side” sets at this point, since the vector sets been permuted and mixed several times by the layers), followed by one or more additional “fast” layers. Additional examples of fast UBDM layers are described below. 
     To perform the non-linear transformation on a single set (e.g., pair) of components, two parameters may be selected: a power p (which can be any real number, e.g., 1, 2, or 3) and a value R, which is a real number. Given the two complex numbers, a rotation is applied to the complex number with the smaller magnitude by an angle proportional to the difference between the two absolute values. The smallest rotation will occur when (r 1 −r 2 )=0, which results in a rotation of 0. The greatest rotation will occur when (r 1 −r 2 ) is the maximum possible distance, which will depend on the constellation being used. 
     For every set of complex numbers as in (20), the difference (r 1 −r 2 ) is calculated, raised to the power p, then multiplied by R to produce a value that will define the degree of phase rotation applied to the complex number having the smaller magnitude. In other words, the following phase shift is calculated:
 
ϕ= R ( r   1   −r   2 ) p  
 
     When r 1 =r 2 , this expression is 0. As (r 1 −r 2 ) increases, ϕ also increases, and the power p controls the rate at which ϕ grows. Once ϕ has been computed, the complex number with the smaller magnitude is multiplied by e jϕ . For example, suppose that in (20) that r 1 &gt;r 2 . The transformation would be: 
     
       
         
           
               
               
               
               
               
               
               
             
               
                   
               
             
            
               
                   
                 r 1 e iθ     1     
                   
                 → 
                   
                 r 1 e iθ     1     
                   
               
               
                  {open oversize parenthesis}  
                   
                  {close oversize parenthesis}  
                   
                  {open oversize parenthesis}  
                   
                  {close oversize parenthesis}  
               
               
                   
                 r 2 e iθ     2     
                   
                   
                   
                 r 2 e i(θ     2     + ∅)   
               
               
                   
               
            
           
         
       
     
     The receiver goes through a similar process, except that once the receiver computes 0, it rotates the complex value with the smaller magnitude in the opposite direction. 
     Fast Unitary Braid Divisional Multiplexing (UBDM) Transforms 
     Overview 
     Consider a basic input including a “baud” vector  b , which is a vector of length N with components in a constellation C. If N=4 and C is a quadrature phase shift keying (QPSK) constellation, an example vector is  b =(1+i,−1+i,−1+i,−i). 
     In some embodiments, applying a “fast” UBDM transformation (or “transform”) to the example vector is b includes applying a nonlinear part (i.e., a nonlinear “transformation”) followed by applying a linear part (i.e., a linear “transformation”). Each of the nonlinear part and the linear part is “keyed” and is implemented using a shared secret between Alice and Bob, the shared secret in the form of a sequence of bits. The nonlinear part includes performing nonlinear operations on the sign bits of one or more input baud vectors, and performing a permutation of the magnitudes. The magnitudes may be permuted without any other change to the magnitudes, during the nonlinear part, for example to preserve the total power of the baud vector. The nonlinear operations on the sign bits can have the effect of imitating a block cipher, and as such, can include all of the nonlinearity of a UBDM transformation. The nonlinear part and the linear part can operate in “layers,” as discussed below. The number of layers (denoted L) in each of the nonlinear part and the linear part can vary, depending on the application, and a number of layers associated with nonlinear part can be the same as or different from a number of layers associated with the linear part. For example, in some embodiments the number of linear layers is L=[log 2 (N)], and the number of nonlinear layers (denoted Q) varies depending on the performance constraints and security constraints of the overall communication system, and may have a value of between Q=0 (least secure) and Q=┌log 2 (N)┐(more secure). 
     In some embodiments, the linear layers are of the form:
 
   b →PU b ,   (1.1.1)
 
where P is a permutation matrix and U is a direct sum of U(2) matrices.
 
Nonlinear Operations
 
     In some embodiments, a nonlinear operation (i.e., a nonlinear part of a fast UBDM transform) includes multiple one-time steps and a series of nonlinear and/or linear layers. The multiple one-time steps can include one or more operations from a general class of operations including, by way of example, S-Box applications, diffusive linear transformations (e.g., a Maximum Difference Separable” (MDS) matrix), Xor additions, permutations, etc. In some embodiments, a nonlinear operation (i.e., a nonlinear part of a fast UBDM transform) includes multiple applications of operations typically found in block ciphers (a general class of symmetric cryptologics), including (but not limited to) Substitution-Permutation-Network (SPN) structures, Feistel Structures, Lai-Massey Structures, S-Boxes of any size, key Xor additions, diffusive linear transformations, permutations, addition-rotation-Xor (ARX) operations, etc. These operations can be applied to the complex values themselves, the sign values, the magnitude values, or any combination, so as to vary the amplitudes, frequencies, and phases of the various components of the signal waveform. The input is the baud vector  b  and multiple shared secrets. If the number of nonlinear layers is Q and there are N subcarriers, the shared secret includes Q+1 permutations of length 2N, Q+1 bit strings of length 2N, and a substitution box (an “S-box”) of a symmetric key algorithm, on any number of bits (e.g., 4 bits or 8 bits). Optionally, there may also be an initialization vector that is a length 2N bit string. The generation, storage, and transmission of each of these elements is discussed below. 
     In some embodiments, a nonlinear operation is applied as follows. First, given a baud vector  b  of N complex numbers, the baud vector  b  is partitioned (i.e., broken up or divided) into its 2N (real and imaginary) magnitudes, and its 2N sign bits. For example, if the initial baud vector is from a 16-state quadrature amplitude modulation (16-QAM) constellation and is  b =(3−i, 1+i,−1+3i, 1+i), the magnitude and sign vectors are:
 
   m   =(3,1,1,1,1,3,1,1)
 
and
 
   s   =(+1,1,+1,+1,1,+1,+1,+1).
 
     For the magnitude vector  m , a single permutation P m  is applied to the elements (optionally without any other modifications to the magnitude vector  m ). Next, for the sign vector  s , the elements are treated/processed as bits and an algorithm resembling a very small block cipher is applied, to produce an intermediate sign vector (or “intermediate vector”). For example, one such implementation is to convert the vector to bits, as follows:
 
   s   =(0,1,0,0,1,0,0,0).
 
     The above modified sign vectors can be referred to as an intermediate sign vector (or “intermediate vector”). A type of modification applied to the sign vector can be selected based on a mode of operation. Examples of modes of operation include, but are not limited to: electronic code book (ECB), cipher block chaining (CBC), counter (CTR), output feedback (OFB), cipher feedback (CFB), etc. ECB is a mode of operation in which a message is divided into blocks of some fixed length, and each block is encrypted separately. CBC is a mode of operation in which a message is divided into blocks of some fixed length, and each block is XORed with the previous cipher text before encrypting. CTR is a mode of operation in which a block cipher is used to encrypt successive values of some “counter,” and the output stream of bits is XORed into the data to create the cipher. OFB is a mode of operation in which a block cipher is used to encrypt an initial random value, and the output of the encryption is fed directly into the encryption for the next block. This creates a stream of bits that can be XORed into the plaintext to create the cipher. CFB is a mode of operation in which a block cipher is used to encrypt an initial random value, which is then XORed into the plaintext, creating cipher. This cipher is then fed directly into the encryption for the next block, which is then XORed into the next data block, and so on. 
     By way of example, in some embodiments, if the mode of operation is a CBC mode, the sign vector is XORed with the length 2N bit vector, the Initialization Vector (IV), that is part of the shared secret. If the mode of operation is an ECB mode, however, the IV may not be applied. Instead, a first step in ECB mode (or a second step in CBC mode) can be to Xor the sign vector with a “seed” vector, which is a length 2N binary vector. This length 2N seed vector can be referred to as bit vector  k   0 . 
     Next, the nonlinear “layers” can be applied, e.g., sequentially from nonlinear layer 1 to nonlinear layer Q. Each nonlinear layer includes an S-Box operation, a permutation P q  (for q∈[1, . . . , Q]), and an additional Xor operation with a fixed binary vector, denoted herein as  k   q . The bit vector  k   0  is referred to as the “seed” and terms  k   1 , . . . ,  k   Q  are referred to as “activators.” Applying each nonlinear layer includes applying the permutation P q , followed by an S-Box transformation, either on blocks of 4 bits or on blocks of 8 bits, followed by Xor-ing that layer&#39;s  k   q . 
     In some embodiments, once all of the nonlinear layers have been applied, and if the system is in CBC mode, the resulting sign vector is saved and subsequently used as an initialization vector of a UBDM transformation of a next baud vector that is to be transformed. 
     Example pseudo-code for a nonlinear transformation in ECB mode is provided below. Given a length N vector of constellation points  b , and shared secrets P m ,  k   0 ,  k   q  for q∈[1, . . . , Q], and P q  for q∈[1, . . . , Q], the input to the algorithm is the baud b of constellation points. 
     
       
         
           
               
               
             
               
                   
               
             
            
               
                   
                   m  ← (|Re(b 1 )|,|Im(b 1 )|,|Re(b 2 )|,|Im(b 2 )|,...,|Re(b N )|,|Im(b N )|) 
               
               
                   
                   s  ← (Sign(Re(b 1 )),Sign(Im(b 1 )),Sign(Re(b 2 )),Sign(Im(b 2 )),...,Sign(Re(b N )),Sign(Im(b N ))) 
               
               
                   
                   m  ← P m ( m ) 
               
               
                   
                   s  ←  k   0  ⊕  s   
               
               
                   
                 FOR q = 1 to Q ; 
               
               
                   
                   s  ← S( s ) 
               
               
                   
                   s  ← P q ( s ) 
               
               
                   
                   s  ←  k   q  ⊕  s   
               
               
                   
                   b  ← (s 1 m 1  + is 2 m 2 ,s 3 m 3  + is 4 m 4 ,...,s 2n −1 m 2n −1  + is 2n m 2n ) 
               
               
                   
               
            
           
         
       
     
     The output of the algorithm is the transformed value  b  (also referred to herein as a modified sign vector). 
     Example pseudo-code for a nonlinear transformation in CBC mode is provided below. Given a length N vector of constellation points  b , and shared secrets I V ,P m , k   0 , k   q  for q∈[1, . . . , Q], and P q  for q∈[1, . . . , Q], the input to the algorithm is the baud b and the initialization vector I V . 
     
       
         
           
               
               
             
               
                   
               
             
            
               
                   
                   m  ← (|Re(b 1 )|,|Im(b 1 )|,|Re(b 2 )|,|Im(b 2 )|,...,|Re(b N )|,|Im(b N )|) 
               
               
                   
                   s  ← (Sign(Re(b 1 )),Sign(Im(b 1 )),Sign(Re(b 2 )),Sign(Im(b 2 )),...,Sign(Re(b N )),Sign(Im(b N ))) 
               
               
                   
                   m  ← P m ( m ) 
               
               
                   
                   s  ← I{umlaut over (V)} ⊕  b   
               
               
                   
                   s  ←  k   0  ⊕  s   
               
               
                   
                 FOR q = 1 to Q ; 
               
               
                   
                   s  ← S( s ) 
               
               
                   
                   s  ← P q ( s ) 
               
               
                   
                   s  ←  k   q  ⊕  s   
               
               
                   
                   b  ← (s 1 m 1  + is 2 m 2 ,s 3 m 3  + is 4 m 4 ,...,s 2n −1 m 2n −1  + is 2n m 2n ) 
               
               
                   
                 I{umlaut over (V)} ←  s   
               
               
                   
               
            
           
         
       
     
     The output of the algorithm is the transformed value  b  and the new initialization vector I V , which will be the input to the next baud vector to be transformed. 
     In some embodiments, when the mode of operation is ECB mode and the algorithm is applied to the same baud vector twice, the same output will be obtained both times. In other embodiments, when the mode of operation is CBC mode, because the initialization vector is used for (and, thus, incorporated into) each transformation, as transformations are performed on successive baud vectors, different outputs may be obtained even if the inputs are the same, thereby providing an additional obstacle for a potential attacker to overcome, and increasing information security. 
     Once the foregoing nonlinear operations have been completed, the linear/unitary part of the “fast” UBDM transform is performed on the output of the nonlinear operations, as discussed below. 
     Example Block U(2) Operations 
     In some embodiments, an action of U is performed on doublets of the vector resulting from previous linear or nonlinear operations. The action of U achieves unitary “mixing” of the components. A single 2×2 block can be of the following form: 
     
       
         
           
             
               
                 
                   
                     U 
                     
                       2 
                       × 
                       2 
                     
                   
                   = 
                   
                     
                       
                         e 
                         iα 
                       
                       ⁡ 
                       
                         ( 
                         
                           
                             
                               
                                 
                                   e 
                                   
                                     i 
                                     ⁢ 
                                     
                                         
                                     
                                     ⁢ 
                                     ψ 
                                   
                                 
                                 ⁢ 
                                 
                                   cos 
                                   ⁡ 
                                   
                                     ( 
                                     θ 
                                     ) 
                                   
                                 
                               
                             
                             
                               
                                 
                                   e 
                                   
                                     i 
                                     ⁢ 
                                     
                                         
                                     
                                     ⁢ 
                                     ϕ 
                                   
                                 
                                 ⁢ 
                                 
                                   sin 
                                   ⁡ 
                                   
                                     ( 
                                     θ 
                                     ) 
                                   
                                 
                               
                             
                           
                           
                             
                               
                                 
                                   - 
                                   
                                     e 
                                     
                                       
                                         - 
                                         i 
                                       
                                       ⁢ 
                                       
                                           
                                       
                                       ⁢ 
                                       ϕ 
                                     
                                   
                                 
                                 ⁢ 
                                 
                                   sin 
                                   ⁡ 
                                   
                                     ( 
                                     θ 
                                     ) 
                                   
                                 
                               
                             
                             
                               
                                 
                                   e 
                                   
                                     
                                       - 
                                       i 
                                     
                                     ⁢ 
                                     
                                         
                                     
                                     ⁢ 
                                     ψ 
                                   
                                 
                                 ⁢ 
                                 
                                   cos 
                                   ⁡ 
                                   
                                     ( 
                                     θ 
                                     ) 
                                   
                                 
                               
                             
                           
                         
                         ) 
                       
                     
                     . 
                   
                 
               
               
                 
                   ( 
                   
                     1.3 
                     ⁢ 
                     .1 
                   
                   ) 
                 
               
             
           
         
       
     
     A total of N/2 of the 2×2 blocks of (1.3.1) can be included along a diagonal of a single matrix U i , and can include 2N complex numbers (where N is the UBDM block size, and, if the system is OFDM, N can refer to a number of subcarriers). To increase efficiency and speed of data retrieval, in some implementations, only the angles α, φ, θ and ϕ are stored, rather than the entireties of the complex numbers. Each of the foregoing angles can be stored using fewer bits (e.g., at least 8 bits for each angle), as compared to storing the entireties of the complex numbers. As such, only 4·8·(N/2)=16N bits may be needed, for storage purposes, per U. When the time comes to compute the complex floats that are actually used in the matrix, if the 8 bit value of, for example, θ, is an integer m (where m is an integer∈[0, 2 m −1]), then θ can be set to 
             θ   =         (     2   π     )     ⁢   m       2   m             
radians. Each of the 4 angles (α, φ, θ and ϕ) can be computed this way, to as many decimal places as is desired.
 
     The action of U 2×2  on two components of a baud vector is as follows: 
     
       
         
           
             
               
                 
                   
                     ( 
                     
                       
                         
                           
                             b 
                             1 
                           
                         
                       
                       
                         
                           
                             b 
                             2 
                           
                         
                       
                     
                     ) 
                   
                   → 
                   
                     
                       ( 
                       
                         
                           
                             
                               
                                 
                                   e 
                                   
                                     i 
                                     ⁢ 
                                     
                                         
                                     
                                     ⁢ 
                                     α 
                                   
                                 
                                 ⁢ 
                                 
                                   e 
                                   
                                     i 
                                     ⁢ 
                                     
                                         
                                     
                                     ⁢ 
                                     ψ 
                                   
                                 
                                 ⁢ 
                                 
                                   cos 
                                   ⁡ 
                                   
                                     ( 
                                     θ 
                                     ) 
                                   
                                 
                                 ⁢ 
                                 
                                   b 
                                   1 
                                 
                               
                               + 
                               
                                 
                                   e 
                                   
                                     i 
                                     ⁢ 
                                     
                                         
                                     
                                     ⁢ 
                                     α 
                                   
                                 
                                 ⁢ 
                                 
                                   e 
                                   
                                     i 
                                     ⁢ 
                                     
                                         
                                     
                                     ⁢ 
                                     ϕ 
                                   
                                 
                                 ⁢ 
                                 
                                   sin 
                                   ⁡ 
                                   
                                     ( 
                                     θ 
                                     ) 
                                   
                                 
                                 ⁢ 
                                 
                                   b 
                                   2 
                                 
                               
                             
                           
                         
                         
                           
                             
                               
                                 
                                   - 
                                   
                                     e 
                                     
                                       i 
                                       ⁢ 
                                       
                                           
                                       
                                       ⁢ 
                                       α 
                                     
                                   
                                 
                                 ⁢ 
                                 
                                   e 
                                   
                                     
                                       - 
                                       i 
                                     
                                     ⁢ 
                                     
                                         
                                     
                                     ⁢ 
                                     ϕ 
                                   
                                 
                                 ⁢ 
                                 
                                   sin 
                                   ⁡ 
                                   
                                     ( 
                                     θ 
                                     ) 
                                   
                                 
                                 ⁢ 
                                 
                                   b 
                                   1 
                                 
                               
                               + 
                               
                                 
                                   e 
                                   
                                     i 
                                     ⁢ 
                                     
                                         
                                     
                                     ⁢ 
                                     α 
                                   
                                 
                                 ⁢ 
                                 
                                   e 
                                   
                                     
                                       - 
                                       i 
                                     
                                     ⁢ 
                                     
                                         
                                     
                                     ⁢ 
                                     ψ 
                                   
                                 
                                 ⁢ 
                                 
                                   cos 
                                   ⁡ 
                                   
                                     ( 
                                     θ 
                                     ) 
                                   
                                 
                                 ⁢ 
                                 
                                   b 
                                   2 
                                 
                               
                             
                           
                         
                       
                       ) 
                     
                     . 
                   
                 
               
               
                 
                   ( 
                   
                     1.3 
                     ⁢ 
                     .2 
                   
                   ) 
                 
               
             
           
         
       
     
     The action of U is as shown above, for each doublet of the components of the vector resulting from the nonlinear operations. The permutations after each U serve to mix/combine as many different components as possible in an unpredictable way. 
     Example pseudocode for the permutations after each U is as follows. Given the initial vector  b  (output as a result of the nonlinear steps outlined above), as well as a permutation P l  for l∈[1, . . . , L], and the collection of block U(2) matrices U, the following is performed: 
     
       
         
           
               
               
               
             
               
                   
                   
               
             
            
               
                   
                   
                   t  =  b   
               
               
                   
                   
                 FOR l = 1 to L 
               
               
                   
                   
                  { t (P l (n)), t (P l (n+1)} = U[l][ 2   c + 1 ]{b[c], b[c+1]} 
               
               
                   
                   
                   b  =  t   
               
               
                   
                   
               
            
           
         
       
     
     In the above pseudocode, U represents the collection of all block U(2) matrices for every layer. So, U[l], where l∈[1, . . . , L], represents the l th  layer block diagonal U(2) matrix. U[l][b], where b∈[1, . . . , N/2], represents the b th  2×2 U(2) block along the diagonal of the matrix at layer l. The notation for the permutations assumes that the permutation P l  is in a “list” format. For example, P l =(3,1,4,2) is a permutation on 4 elements, where each value designates a resulting index for that element. 
     Example Permutation Operations 
     A variety of different permutations can be used in both the nonlinear part of the fast UBDM transform and linear part of the fast UBDM transform. Example efficient methods for generating and storing such permutations are presented below. 
     Note that, for N objects, N! unique permutations exist. In other words, if a map is defined from the integers [0, N!), one such integer can be generated at random and then mapped to the corresponding permutation, for example using Lehmer codes. Lehmer codes facilitate the conversion (or mapping) of permutations to integers, and the conversion (or mapping) of integers to permutations, in a fast and efficient manner. An example mapping integers to permutations is discussed below. 
     Suppose N=4. Given that 4!=24, there are 24 permutations, which can be labeled using the integers 0 . . . 23. One of these integers may first be selected at random. Suppose the selected integer is 17. Next, the integer is converted from base-10 to “base factorial,” for example as follows:
 
17÷1=17 remainder 0,  (1.4.1)
 
17÷2=8 remainder 1  (1,4.2)
 
8÷3=2 remainder 2  (1.4.3)÷
 
2÷4=0 remainder 2.  (1.4.4)
 
     The conversion terminates when the quotient is 0 (optionally with a remainder). The factorial expression is then obtained using the remainder values, as follows:
 
2×3!+2×2!+1×1!+0×0!=2×6+2×2+1×1=12+4+1=17.  (1.4.5)
 
     Once the factorial representation of the integer has been obtained, which can be written as (2,2,1,0), the following algorithm is performed. The process begins with the rightmost component and moves leftward. At each step, every value to the right of the component in question is increased by 1 if and only if it is equal to or greater than the component in question. For the above example:
 
(2,2,1, 0 ) nothing to do
 
(2,2, 1 ,0) nothing to do
 
(2, 2 ,1,0) nothing to do
 
( 2 ,2,1,0) increase the second component by 1 because it is equal to the underlined value
 
(2,3,1,0)  (1.4.6)
 
     The last term in the above list, (2,3,1,0), represents the permutation. Each element in the permutation corresponds to a column in P, and the positions within each column of P are positions 0, 1, 2, and 3, in a downward, vertical direction. It indicates that the first element goes to position 2, the second element goes to position 3, the third element goes to position 1, and the last element goes to position 0. The matrix representation of this permutation is: 
     
       
         
           
             
               
                 
                   P 
                   = 
                   
                     ( 
                     
                       
                         
                           0 
                         
                         
                           0 
                         
                         
                           0 
                         
                         
                           1 
                         
                       
                       
                         
                           0 
                         
                         
                           0 
                         
                         
                           1 
                         
                         
                           0 
                         
                       
                       
                         
                           1 
                         
                         
                           0 
                         
                         
                           0 
                         
                         
                           0 
                         
                       
                       
                         
                           0 
                         
                         
                           1 
                         
                         
                           0 
                         
                         
                           0 
                         
                       
                     
                     ) 
                   
                 
               
               
                 
                   ( 
                   
                     1.4 
                     ⁢ 
                     .7 
                   
                   ) 
                 
               
             
           
         
       
     
     Consider another example, in which the integer is 8. The factorial representation is:
 
8÷1=8 remainder 0
 
8÷2=4 remainder 0
 
4÷3=1 remainder 1
 
1÷4=0 remainder 1.
 
So, indeed:
 
1×3!+1×2!+0×1!+0×0!=8.  (1.4.8)
 
Next,
 
(1,1,0, 0 ) nothing to do
 
(1,1, 0 ,0) we increase the last 0 by 1
 
(1, 1 ,0,1) the 0 stays the same, but we increase the last 1 by 1
 
( 1 ,1,0,2) the second 1 and the 2 both increase by 1
 
(1,2,0,3).  (1.4.9)
 
     This corresponds to the permutation matrix: 
     
       
         
           
             
               
                 
                   P 
                   = 
                   
                     ( 
                     
                       
                         
                           0 
                         
                         
                           0 
                         
                         
                           1 
                         
                         
                           0 
                         
                       
                       
                         
                           1 
                         
                         
                           0 
                         
                         
                           0 
                         
                         
                           0 
                         
                       
                       
                         
                           0 
                         
                         
                           1 
                         
                         
                           0 
                         
                         
                           0 
                         
                       
                       
                         
                           0 
                         
                         
                           0 
                         
                         
                           0 
                         
                         
                           1 
                         
                       
                     
                     ) 
                   
                 
               
               
                 
                   ( 
                   
                     1.4 
                     ⁢ 
                     .10 
                   
                   ) 
                 
               
             
           
         
       
     
     In some embodiments, to generate the permutations for a given N, a random integer between 0 and N!−1 is selected and converted to base factorial. The resulting array is then converted to a permutation. A number of bits to accommodate an integer between 0 and N!−1 may be determined, for example, using Sterling&#39;s approximation, which in some implementations can provide a slight over-estimate. Then, rather than converting the resulting bit string into an integer followed by converting that integer to its base factorial form, the number of bits for each value can be directly approximated. Note that a general number in base factorial is of the form:
 
 x=a   0 ×0!+ a   1 ×1!+ a   2 ×2!+ a   3 ×3!+  (1.4.11)
 
     The values a n  are between 0 and n, and represent the numbers of bits to be read for each value. As an example, suppose N=8. The approximate number of bits to be read is thus:
 
log 2 ( N !)≈ N  log 2 ( N )− N= 8·3−8=16.  (1.4.12)
 
     Next, consider a list of 16 random bits (e.g., using a pseudorandom number generator, such as the PRNG function in Mathematica):
 
(0,0,1,0,0,0,1,0,1,0,0,1,0,1,1,0)
 
     The first term in the above list of 16 random bits is the coefficient of 0!, which is 0, so that term can be ignored. The second term in the above list of 16 random bits is the coefficient of 1!, which is either 0 or 1. Given that the first bit above (far left in this case), which is 0, a 1 =0. That first bit is then cut off (removed) from the list of 16 random bits string, leaving the following list of 15 bits:
 
(0,1,0,0,0,1,0,1,0,0,1,0,1,1,0)
 
     Next, the value a 2  is obtained. This value can be 0, 1, or 2, and as such, a 2  is represented by 2 bits. Since 2 bits can store more than just 3 possible values, consider taking the value mod 2+1=3. The next two bits (the two far left bits in the above list of 15 bits) are 0 and 1, which have a value (when concatenated, i.e., “01”) of 1, so a 2  is set to a 2 =1. Again cutting off (removing) the first 2 bits from the above list of 15 bits leaves the following list of 13 bits:
 
(0,0,0,1,0,1,0,0,1,0,1,1,0)
 
     Next, for a 3 , the value can be 0, 1, 2, or 3, and as such, a 3  is represented by 2 bits. The first two bits (the two far left bits in the above list of 13 bits) are 0 and 0, which have a value (when concatenated, i.e., “00”) of 0, so a 3  is set to a 3 =0. Again cutting off (removing) the first 2 bits from the above list of 13 bits leaves the following list of 11 bits:
 
(0,1,0,1,0,0,1,0,1,1,0)
 
     Next, for a 4 , the value can be 0, 1, 2, 3, or 4, and as such, a 4  is represented by 3 bits. The next three bits (the three far left bits in the above list of 11 bits) are (0,1,0), which have a value (when concatenated, i.e., “010”) of 2, so a 4  is set to a 4 =2. Cutting off (removing) the first 3 bits from the above list of 11 bits leaves the following list of 8 bits:
 
(1,0,0,1,0,1,1,0)
 
     Next, for a 5 , there are 6 values, and as such, a 5  is represented by 3 bits, which in this example (reading the three far left bits in the above list of 8 bits) are (1,0,0), or 4. So a 5 =4, and cutting off (removing) the first 3 bits from the above list of 8 bits leaves the following list of 5 bits:
 
(1,0,1,1,0)
 
     Next, a 6  is represented by 3 bits, which in this example (reading the three far left bits in the above list of 5 bits) are (1,0,1), or 5, so a 6 =5. Cutting off (removing) the first 3 bits from the above list of 5 bits leaves the following 2 bits:
 
(1,0)
 
     Finally, for a 7 , there are 8 possibilities, and as such, a 7  is represented by 3 bits. Since only 2 bits remain, one additional bit can be generated at random (in this case, 1) and appended to the list to yield:
 
(1,0,1),
 
and as such, a 7 =5.
 
     Note that the addition of the extra bit may have been predicted using the following equation: 
     
       
         
           
             
               
                 
                   
                     number 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     of 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     bits 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     required 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     for 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     a 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     permutation 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     of 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     size 
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     N 
                   
                   = 
                   
                     
                       ∑ 
                       
                         n 
                         = 
                         1 
                       
                       
                         N 
                         - 
                         1 
                       
                     
                     ⁢ 
                     
                         
                     
                     ⁢ 
                     
                       
                         ⌈ 
                         
                           
                             log 
                             2 
                           
                           ⁡ 
                           
                             ( 
                             
                               n 
                               + 
                               1 
                             
                             ) 
                           
                         
                         ⌉ 
                       
                       . 
                     
                   
                 
               
               
                 
                   ( 
                   
                     1.4 
                     ⁢ 
                     .13 
                   
                   ) 
                 
               
             
           
         
       
     
     When N=8, equation 1.4.13 yields a value of 17. The original random bit string with the appended bit (now of length 17) is:
 
(0,0,1,0,0,0,1,0,1,0,0,1,0,1,1,0,1),
 
which as described above, produces a base factorial number of (5,5,4,2,0,1,0,0). Applying a permutation to the base factorial number yields:
 
(5,5,4,2,0,1, 0 ,0)
 
(5,5,4,2,0, 1 ,0,1)
 
(5,5,4,2, 0 ,1,0,2)
 
(5,5,4, 2 ,0,2,1,3)
 
(5,5, 4 ,2,0,3,1,4)
 
(5, 5 ,4,2,0,3,1,5)
 
( 5 ,5,4,2,0,3,1,6)
 
(5,6,4,2,0,3,1,7)  (1.4.14)
 
     Note that the last (bottom) line is a valid permutation on 8 objects. 
     In some embodiments, a permutation is inverted, for example as follows. First, the permutation is arranged on a first line and the associated integers are arranged in consecutive order on a second line below the first line. For the above example, the lines appear as follows: 
     
       
         
           
             
               
                 
                   
                     ( 
                     
                       
                         
                           5 
                         
                         
                           6 
                         
                         
                           4 
                         
                         
                           2 
                         
                         
                           0 
                         
                         
                           3 
                         
                         
                           1 
                         
                         
                           7 
                         
                       
                       
                         
                           0 
                         
                         
                           1 
                         
                         
                           2 
                         
                         
                           3 
                         
                         
                           4 
                         
                         
                           5 
                         
                         
                           6 
                         
                         
                           7 
                         
                       
                     
                     ) 
                   
                   . 
                 
               
               
                 
                   ( 
                   
                     1.4 
                     ⁢ 
                     .15 
                   
                   ) 
                 
               
             
           
         
       
     
     Next, the columns are rearranged so that the top row is in sequential order, resulting in the following: 
     
       
         
           
             
               
                 
                   
                     ( 
                     
                       
                         
                           0 
                         
                         
                           1 
                         
                         
                           2 
                         
                         
                           3 
                         
                         
                           4 
                         
                         
                           5 
                         
                         
                           6 
                         
                         
                           7 
                         
                       
                       
                         
                           4 
                         
                         
                           6 
                         
                         
                           3 
                         
                         
                           5 
                         
                         
                           2 
                         
                         
                           0 
                         
                         
                           1 
                         
                         
                           7 
                         
                       
                     
                     ) 
                   
                   . 
                 
               
               
                 
                   ( 
                   
                     1.4 
                     ⁢ 
                     .16 
                   
                   ) 
                 
               
             
           
         
       
     
     The bottom row in 1.4.16 is the inverse permutation. This result can be verified by inspecting the corresponding matrices. The matrix corresponding to (5,6,4,2,0,3,1,7) (using the convention above) is: 
     
       
         
           
             
               
                 
                   ( 
                   
                     
                       
                         0 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         1 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         0 
                       
                     
                     
                       
                         0 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         1 
                       
                       
                         0 
                       
                     
                     
                       
                         0 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         1 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         0 
                       
                     
                     
                       
                         0 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         1 
                       
                       
                         0 
                       
                       
                         0 
                       
                     
                     
                       
                         0 
                       
                       
                         0 
                       
                       
                         1 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         0 
                       
                     
                     
                       
                         1 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         0 
                       
                     
                     
                       
                         0 
                       
                       
                         1 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         0 
                       
                     
                     
                       
                         0 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         1 
                       
                     
                   
                   ) 
                 
               
               
                 
                   ( 
                   
                     1.4 
                     ⁢ 
                     .17 
                   
                   ) 
                 
               
             
           
         
       
     
     The inverse permutation (4,6,3,5,2,0,1,7) corresponds to the matrix: 
     
       
         
           
             
               
                 
                   ( 
                   
                     
                       
                         0 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         1 
                       
                       
                         0 
                       
                       
                         0 
                       
                     
                     
                       
                         0 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         1 
                       
                       
                         0 
                       
                     
                     
                       
                         0 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         1 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         0 
                       
                     
                     
                       
                         0 
                       
                       
                         0 
                       
                       
                         1 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         0 
                       
                     
                     
                       
                         1 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         0 
                       
                     
                     
                       
                         0 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         1 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         0 
                       
                     
                     
                       
                         0 
                       
                       
                         1 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         0 
                       
                     
                     
                       
                         0 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         0 
                       
                       
                         1 
                       
                     
                   
                   ) 
                 
               
               
                 
                   ( 
                   
                     1.4 
                     ⁢ 
                     .18 
                   
                   ) 
                 
               
             
           
         
       
     
     It is clear from inspection of 1.4.17 and 1.4.18 that the matrices are inverses of each other (i.e., one is the transpose of the other). 
     Modification for Peak to Average Power Ratio (PAPR) Reduction 
     In some embodiments, a modification to the fast UBDM transform is performed, such that the PAPR is reduced. Implementing such a modification can involve one or more slight changes to the algorithm, however the total number of generator bits and their usage can be largely the same. Examples of such changes to the algorithm are outlined below. 
     PAPR Reduction in the Nonlinear Transformation 
     In one or more embodiments, a modification to the nonlinear part of the fast UBDM transform is performed when an APSK constellation is used, for example because the non-square shape of an APSK constellation can result in undesirable bulging under UBDM. For example, consider the points a+bi and b+ai, where a&gt;b. In a square constellation, the value a+ai would likely also be a part of the constellation. Circular APSK constellations specifically avoid having such “edge” constellation points. However, when performing a fast UBDM transform as described herein, the permutation of the magnitude transformation in the nonlinear part of the transform can include swapping the points a+ib and b+ia to a+ai and b+bi. The point a+ai will generally have a greater magnitude than either of a+bi or b+ai, and the overall PAPR will have increased as a result. To avoid or mitigate such effects, a modification can be made to the way the magnitude vector transforms in the nonlinear transformation, as illustrated by the following example. 
     Consider a case in which N=4. The magnitude permutation is defined by a length 2N=8 permutation. For example, the permutation may be (2,4,1,5,3,8,6,7). The permutation is first separated into two lists of length N: a first list in which each element is less than or equal to N, and a second list in which each element is greater than N, without changing the order of appearance of the elements relative to the permutation. In the current example, the two lists are (2,4,1,3) and (5,8,6,7). Notice that the first of these lists is a valid permutation on N elements. Next, the “top half” (5,8,6,7) is reduced modulo 2, resulting in the following modified second list: (1,0,0,1). 
     In some embodiments, when performing the nonlinear part of the fast UBDM transform, we use both of these vectors (i.e., the first list and the modified second list) to modify the constellation vector. Suppose the original constellation vector is: 
     
       
         
           
             
               
                 
                   ( 
                   
                     
                       
                         
                           
                             a 
                             1 
                           
                           + 
                           
                             i 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             
                               b 
                               1 
                             
                           
                         
                       
                     
                     
                       
                         
                           
                             a 
                             2 
                           
                           + 
                           
                             i 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             
                               b 
                               2 
                             
                           
                         
                       
                     
                     
                       
                         
                           
                             a 
                             3 
                           
                           + 
                           
                             i 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             
                               b 
                               3 
                             
                           
                         
                       
                     
                     
                       
                         
                           
                             a 
                             4 
                           
                           + 
                           
                             i 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             
                               b 
                               4 
                             
                           
                         
                       
                     
                   
                   ) 
                 
               
               
                 
                   ( 
                   
                     1.5 
                     ⁢ 
                     .1 
                   
                   ) 
                 
               
             
           
         
       
     
     The length 2N magnitude vector would then be (a 1 , b 1 , a 2 , b 2 , a 3 , b 3 , a 4 , b 4 ). Note that the absolute value notation (e.g., the bars in |a i |) are omitted in the above, to avoid cluttering the notation, however the magnitude vector includes the magnitudes of the real and imaginary parts, rather than just the real and imaginary parts. In the fast UBDM transform procedure described above, the length 2N permutation would be applied to the constellation vector. In the PAPR-reduction transformation, however, the following is performed: 
     First, the magnitude vector is partitioned into blocks of 2, pairing the real and imaginary parts of each number. As such, the magnitude vector becomes the partitioned magnitude vector ((a 1 , b 1 ), (a 2 , b 2 ), (a 3 , b 3 ), (a 4 , b 4 )). The partitioned magnitude vector is then acted on using a length N permutation produced from the original length 2N permutation. In this case, the length N permutation is (2,4,1,3), so the partitioned magnitude vector becomes a permuted partitioned magnitude vector ((a 2 , b 2 ), (a 4 , b 4 ), (a 1 , b 1 ), (a 3 , b 3 )). Next, using the binary vector produced from the vector above, the following is obtained: ((b 2 , a 2 ), (a 4 , b 4 ), (a 1 , b 1 ), (b 3 , a 3 )). 
     The foregoing is then rearranged into the vector: 
     
       
         
           
             
               
                 
                   ( 
                   
                     
                       
                         
                           
                             b 
                             2 
                           
                           + 
                           
                             i 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             
                               a 
                               2 
                             
                           
                         
                       
                     
                     
                       
                         
                           
                             a 
                             4 
                           
                           + 
                           
                             i 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             
                               b 
                               4 
                             
                           
                         
                       
                     
                     
                       
                         
                           
                             a 
                             1 
                           
                           + 
                           
                             i 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             
                               b 
                               1 
                             
                           
                         
                       
                     
                     
                       
                         
                           
                             b 
                             3 
                           
                           + 
                           
                             i 
                             ⁢ 
                             
                                 
                             
                             ⁢ 
                             
                               a 
                               3 
                             
                           
                         
                       
                     
                   
                   ) 
                 
               
               
                 
                   ( 
                   
                     1.5 
                     ⁢ 
                     .2 
                   
                   ) 
                 
               
             
           
         
       
     
     The signs of each of the numbers in vector 1.5.2 can be determined using a procedure similar to the example nonlinear operations on sign bits during the fast UBDM transform, discussed above. In some embodiments, the foregoing modification to the nonlinear part of the fast UBDM transform is used when a reduction in PAPR is desired and/or an APSK constellation is being used. 
     PAPR Reduction in the Linear Transformation 
     In one or more embodiments, a modification to the linear/unitary part of the fast UBDM transform is performed, for example to restrict the values of 0 in the baud vector (1.3.2). In the Block U(2) Operations section above, the angle bits were used to select an angle from a uniform distribution on [0, 2π]. To reduce PAPR, the value of this angle may be scaled to be close to 0, for example by selecting a value r∈(0,1]. The closer the value r is to 1, the greater the PAPR will be. If r=0, the PAPR will be identical to the original PAPR, particularly if the constellation was QAM. If the constellation is APSK, a modification to the nonlinear part of the fast UBDM transform, described in the previous section, may also be performed. In some embodiments, a value of r=0.01 is desirable. Values outside of the interval [0,1] can also be acceptable. 
     Once a value of r has been selected, the value Θ that was chosen by the generator bits is changed to: 
     
       
         
           
             
               
                 
                   
                     θ 
                     -&gt; 
                     
                       θ 
                       ′ 
                     
                   
                   = 
                   
                     
                       r 
                       4 
                     
                     ⁢ 
                     
                       
                         ( 
                         
                           θ 
                           - 
                           π 
                         
                         ) 
                       
                       . 
                     
                   
                 
               
               
                 
                   ( 
                   
                     1.5 
                     ⁢ 
                     .3 
                   
                   ) 
                 
               
             
           
         
       
     
     θ′ can then be used in the block U(2) transformations. The foregoing changes can be implemented without modifying the generator bits that are produced. In other words, the same generator bits can be used, but the θ values are scaled in each of the U(2) blocks. 
     MEM Diffusion 
     In some embodiments, a “MEM” operation is performed during the nonlinear part of the fast UBDM transform. The MEM operation includes taking the sign vector  s , treating it as a binary vector (e.g.  s =(1,1,0,1,1,1,0,0), rather than (−1,−1,1,−1,−1,−1,1,1)), and flipping each bit if and only if the Hamming weight of the vector is even. The Hamming weight or a string is the number of symbols that are different from the zero-symbol of the alphabet being used. A few examples are as follows:
 
(1,1,0,1,1,1,0,0)⇒(1,1,0,1,1,1,0,0)
 
(1,1,0,1,1,1,0,1)⇒(0,0,1,0,0,0,1,0)
 
(0,1,0,1,1,1,1,0)⇒(1,0,1,0,0,0,0,0)
 
(0,1,0,1,0,1,0,0)⇒(0,1,0,1,0,1,0,0)
 
     Alternatively, if the sign vector is represented in terms of {±1}, the operation can be as follows:
 
   s   →(−1) #[s,−1]     s ,   (1,6.1)
 
where #[ā,b] returns a number of occurrences of b in ā. The MEM operation can be used, for example, to quickly and efficiently maximize diffusion.
 
Nonlinear Transformation Example
 
     The following is an example implementation of a nonlinear part of a fast UBDM transform, in accordance with one or more embodiments. Consider a 16 QAM block:
 
(3− i,− 1+ i,− 3−3 i, 1+3 i ).  (0.-1.1)
 
     As can be observed in (0.-1.1), in this example the block size is N=4. 
     First, the block is partitioned or broken up into two separate length 2N vectors—a first vector capturing the magnitudes of the real and imaginary parts, and a second vector capturing the signs of the real and imaginary parts. In this example, these first and second vectors are:
 
   m   =(3,1,1,1,3,3,1,3),
 
   s   =(1,−1,−1,1,−1,−1,1,1),  (0.-1.2)
 
     For the magnitude vector, a permutation is applied, the permutation depending on the generator bits/key values. For example, the permutation, “π,” may be:
 
π=(6,2,4,1,8,3,7,5).  (0.-1.3)
 
     Applying the permutation (0.-1.3) to the magnitude vector produces the following new magnitude vector:
 
   m   →π(   m   )=(3,1,1,3,3,1,3),  (0.-1.4)
 
     Note that the value originally in the 6 th  place in  m  has moved to the 1 st  place, the value originally in the second place has remained in the second place, the value in the 4 th  place has moved to the 3 rd  place, etc. 
     Next, a block cipher is applied to the sign bits. For example, the sign values can be converted into bits as follows:
 
(1,−1,−1,1,−1,1,1)→(0,1,1,0,1,1,0,0).  (0.-1.5)
 
     A “Substitution-Permutation-Network” (SPN) cipher is used for this example, however other types of block ciphers would also work (e.g., Feistel ciphers, Lai-Massey ciphers, etc). 
     The sign bits of (0.-1.5) are Xor&#39;ed with a generator/seed value. For example, the seed value may be (1,0,0,1,1,1,1,0). The output of the Xor operation is:
 
(0,1,1,0,1,1,0,0)⊕(1,0,0,1,1,1,1,0)=(1,1,1,1,0,0,1,0).  (0.-1.6)
 
     Next, a “substitution box”, or “s-box,” is applied. Applying the s-box includes replacing a collection of bits of a predefined block size with other bits of the same block size. For the current example, consider a 4-bit s-box, defined by the following lookup table:
 
(0,0,0,0)→(0,0,0,0)(1,0,0,0)→(1,0,0,0)
 
(0,0,0,1)→(0,0,0,1)(1,0,0,1)→(1,0,1,1)
 
(0,0,1,0)→(0,0,1,0)(1,0,1,0)→(1,1,0,0)
 
(0,0,1,1)→(1,1,0,1)(1,0,1,1)→(1,0,0,1)
 
(0,1,0,0)→(0,1,1,1)(1,1,0,0)→(0,0,1,1)
 
(0,1,0,1)→(0,1,1,1)(1,1,0,1)→(1,1,1,0)
 
(0,1,1,0)→(1,1,1,1)(1,1,1,0)→(1,0,1,0)
 
(0,1,1,1)→(0,1,1,0)(1,1,1,1)→(0,1,0,1)  (0.-1.7)
 
     To apply this s-box, the bit string (1, 1, 1, 1, 0, 0, 1, 0) of (0.-1.6) is broken into blocks of four bits each. These blocks are (1, 1, 1, 1) and (0, 0, 1, 0). Using the s-box, it can be observed that: (1, 1, 1, 1)→(0, 1, 0, 1) and (0, 0, 1, 0)→(0, 0, 1, 0). 
     So, the bit string is now:
 
(0,1,0,1,0,0,1,0)  (0.-1.8)
 
     Next, a permutation is applied to the bit string. For the current example, the permutation π=(1, 3, 5, 7, 2, 4, 6, 8) is used, and the bit string becomes:
 
π(0,1,0,1,0,0,1,0)=(0,0,0,1,1,1,0,0)  (0.-1.9)
 
     The foregoing process is then repeated, by Xor&#39;ing another 8-bit string, applying the s-box, then applying a permutation, and so on. In the end, a final 8-bit string is obtained, which is converted back into signs, for example as follows (note that the following does not reflect any repetition of the transformation):
 
(0,0,0,1,1,1,0,0)→(1,1,1,−1,−1,−1,1,1)  (0.-1.10)
 
     The vector (0.-1.10) is then combined with the permuted magnitude vector  m , and the length N complex vector is reassembled:
 
(3+ i,i− 3 i,− 3 i−i, 1+3 i ).  (0.-1.11)
 
     The vector (0.-1.11) is a vector of constellation points that is subsequently passed to the linear/unitary part (layers/rounds) of the fast UBDM transform. 
     The repetitions described above (Xor→s-box→permutation) can be referred to as “rounds” or “layers.” The Xor values can be referred to as “round keys,” “seeds,” or “activators.” In some embodiments, the same s-box is applied in each layer from multiple layers. In other embodiments, a different s-box is applied in each layer from multiple layers. In still other embodiments, two or more different s-boxes can be used within multiple layers. The permutations can be the same every round/layer or they can be different every time. Similarly, in some embodiments, the same permutation is used in each layer from multiple layers. In other embodiments, a different permutation is used in each layer from multiple layers. In still other embodiments, two or more different permutations are used within multiple layers. 
     Each of the number of layers/rounds, the actual value of the Xor values (seeds/generators), and the value of the s-box, can be variable and/or predefined. Whether or not each of the number of layers/rounds, the actual value of the Xor values (seeds/generators), and the value of the s-box are keyed or fixed can be variable and/or predefined. Although in the above example, the block size was N=4, and therefore the length of   and   was 8, the size of the block can be variable and/or predefined. Although in the above example, the size of the s-box was 4, the size of the s-box can be variable and/or predefined, and can be any size of a variety of sizes (e.g., 8). Notwithstanding the examples provided above, the order and manner in which the permutations, s-boxes, additions, etc. are stacked/implemented can be variable and/or predefined. 
       FIG.  5    is a flowchart illustrating an example method  500  for implementing a fast UBDM transform, according to an embodiment. As shown in  FIG.  5   , the method  500  includes receiving a first vector via a processor, at  510 , and partitioning the first vector at  512  to produce a magnitude vector and a sign vector. A second vector, including a modified magnitude vector and a modified sign vector, is generated at  514  by: applying, at  514 A, a permutation to the magnitude vector to produce the modified magnitude vector; converting the sign vector, at  514 B, based on an algorithm, into an intermediate sign vector; and applying, at  514 C, a plurality of nonlinear layers to the intermediate sign vector, to produce the modified sign vector. The converting the sign vector at  514 B is optionally based on an initialization vector. Each nonlinear layer from the plurality of nonlinear layers includes at least one of, or any combination of, a permutation, an S-box transformation, a diffusive linear operation, or an Xor operation, as discussed herein. A plurality of linear layers is applied to the second vector, at  516 , to produce a third vector, the third vector being a transformed version of the first vector. A first signal representing the third vector is sent, at  518 , for example to at least one transmitter for transmission of a second signal representing the transformed data vector from the at least one transmitter to at least one receiver. In some implementations, the permutation applied to the magnitude vector does not reduce a total power of the first vector. 
     In some embodiments, the method  500  also includes selecting the algorithm based on an encryption mode of operation of the processor. The algorithm can include an Xor operation, and an encryption mode of operation of the processor can be a cipher block chaining (CBC) mode or an electronic code book (ECB) mode. A number of nonlinear layers in the plurality of nonlinear layers can be the same as, or different from, a number of linear layers in the plurality of linear layers. 
     In some embodiments, at least one of a number of linear layers (“L”) in the plurality of linear layers or a number of nonlinear layers (“Q”) in the plurality of nonlinear layers is equal to [log 2 (N)]. 
     In some embodiments, at least one of a number of nonlinear layers in the plurality of nonlinear layers or a number of linear layers in the plurality of linear layers is based on a performance constraint and/or a security constraint (e.g., of a given communications system or component thereof). 
       FIG.  6    is a flowchart illustrating an example method  600  for implementing a fast UBDM transform, according to an embodiment. As shown in  FIG.  6   , the method  600  includes receiving, via a processor, an input vector, at  620 , the input vector including a plurality of complex numbers. A transformed vector is generated, at  622 , based on the input vector and via the processor, by: applying a permutation, at  622 A, to a magnitude vector associated with the input vector, to produce a modified magnitude vector; applying an algorithm at  622 B (e.g., including an Xor operation) and a plurality of nonlinear layers to a sign vector associated with the input vector, to produce a modified sign vector, the modified magnitude vector and the modified sign vector defining an intermediate vector; and applying, at  622 C, a plurality of linear layers to the intermediate vector to produce the transformed vector. The method  600  also includes sending a signal representing the transformed vector, at  624 , e.g., to at least one transmitter for transmission of a second signal representing the transformed vector from the at least one transmitter to at least one receiver. In some implementations, the permutation applied to the magnitude vector does not reduce a total power of the input vector. 
     In some embodiments, each nonlinear layer from the plurality of nonlinear layers includes at least one of: a permutation, an S-box transformation, a diffusive linear operation, or an Xor operation. The method  600  can also include selecting the algorithm based on an encryption mode of operation of the processor (e.g., a cipher block chaining (CBC) mode or an electronic code book (ECB) mode). 
     A number of nonlinear layers in the plurality of nonlinear layers can be the same as, or different from, a number of linear layers in the plurality of linear layers. At least one of a number of nonlinear layers in the plurality of nonlinear layers or a number of linear layers in the plurality of linear layers can be based on at least one of a performance constraint or a security constraint. 
     In some embodiments, at least one of a number of linear layers (“L”) in the plurality of linear layers or a number of nonlinear layers (“Q”) in the plurality of nonlinear layers is equal to [log 2 (N)]. 
     While various embodiments have been described above, it should be understood that they have been presented by way of example only, and not limitation. Where methods and/or schematics described above indicate certain events and/or flow patterns occurring in certain order, the ordering of certain events and/or flow patterns may be modified. While the embodiments have been particularly shown and described, it will be understood that various changes in form and details may be made. Additionally, certain of the steps may be performed concurrently in a parallel process when possible, as well as performed sequentially as described above. Although various embodiments have been described as having particular features and/or combinations of components, other embodiments are possible having any combination or sub-combination of any features and/or components from any of the embodiments described herein. Furthermore, although various embodiments are described as having a particular entity associated with a particular compute device, in other embodiments different entities can be associated with other and/or different compute devices. 
     It is intended that the systems and methods described herein can be performed by software (stored in memory and/or executed on hardware), hardware, or a combination thereof. Hardware modules may include, for example, a general-purpose processor, a field programmable gates array (FPGA), and/or an application specific integrated circuit (ASIC). Software modules (executed on hardware) can be expressed in a variety of software languages (e.g., computer code), including Unix utilities, C, C++, Java™, JavaScript, Ruby, SQL, SAS®, Python, Fortran, the R programming language/software environment, Visual Basic™, and other object-oriented, procedural, or other programming language and development tools. Examples of computer code include, but are not limited to, micro-code or micro-instructions, machine instructions, such as produced by a compiler, code used to produce a web service, and files containing higher-level instructions that are executed by a computer using an interpreter. Additional examples of computer code include, but are not limited to, control signals, encrypted code, and compressed code. Each of the devices described herein can include one or more processors as described above. 
     Some embodiments described herein relate to devices with a non-transitory computer-readable medium (also can be referred to as a non-transitory processor-readable medium or memory) having instructions or computer code thereon for performing various computer-implemented operations. The computer-readable medium (or processor-readable medium) is non-transitory in the sense that it does not include transitory propagating signals per se (e.g., a propagating electromagnetic wave carrying information on a transmission medium such as space or a cable). The media and computer code (also can be referred to as code) may be those designed and constructed for the specific purpose or purposes. Examples of non-transitory computer-readable media include, but are not limited to: magnetic storage media such as hard disks, and solid state storage devices; optical storage media such as Compact Disc/Digital Video Discs (CD/DVDs), Compact Disc-Read Only Memories (CD-ROMs), and holographic devices; magneto-optical storage media such as optical disks; carrier wave signal processing modules; and hardware devices that are specially configured to store and execute program code, such as Application-Specific Integrated Circuits (ASICs), Programmable Logic Devices (PLDs), Read-Only Memory (ROM) and Random-Access Memory (RAM) devices. Other embodiments described herein relate to a computer program product, which can include, for example, the instructions and/or computer code discussed herein. 
     Processor-executable instructions can be in many forms, such as program modules, executed by one or more compute devices, and can include routines, programs, objects, components, data structures, and other suitable code that causes a processor to perform particular tasks or implement particular data types, and the functionality can be combined and/or distributed as appropriate for various embodiments. 
     The phrase “and/or,” as used herein in the specification and in the claims, should be understood to mean “either or both” of the elements so conjoined, i.e., elements that are conjunctively present in some cases and disjunctively present in other cases. Multiple elements listed with “and/or” should be construed in the same fashion, i.e., “one or more” of the elements so conjoined. Other elements may optionally be present other than the elements specifically identified by the “and/or” clause, whether related or unrelated to those elements specifically identified. Thus, as a non-limiting example, a reference to “A and/or B”, when used in conjunction with open-ended language such as “comprising” can refer, in one embodiment, to A only (optionally including elements other than B); in another embodiment, to B only (optionally including elements other than A); in yet another embodiment, to both A and B (optionally including other elements); etc.