Modulation agnostic transform using unitary braid division multiplexing (UBDM)

Abstract

A method for implementing a fast UBDM transform includes receiving a first input vector via a processor, and partitioning the first vector to produce a magnitude vector and a sign vector. A second vector comprising a modified magnitude vector and a modified sign vector is generated by applying a permutation to the vector value vector to produce the modified magnitude vector, converting the sign vector to an intermediate sign vector based on an algorithm, and applying a non-linear layer to the intermediate sign vector. Each non-linear layer comprises a permutation, an S-box transform, a diffusion linear operation, and / or an exclusive OR operation. A plurality of linear layers are 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 sending a second signal representing the transformed data vector.

Description

[0001] Cross-references to related applications

[0002] This application claims priority to and is a continuation-to-priority of U.S. Patent Application No. 16 / 459,254, filed July 1, 2019, entitled "Communication System and Method Using Orthogonal Frequency Division Multiplexing (OFDM) with Non-Linear Transformation," and also claims priority to and is a continuation-to-priority of U.S. Patent Application No. 16 / 916,303, filed June 30, 2020, entitled "Modulation-Agnostic Transformations Using Unitary Braid Divitional Multiplexing (UBDM)." The disclosure of each prior application is incorporated herein by reference in its entirety for all purposes.

[0003] This application relates to U.S. non-provisional patent application No. 16 / 416,144, filed May 17, 2019, entitled “COMMUNICATION SYSTEM AND METHODSUSING MULTIPLE–IN-MULTIPLE–OUT (MIMO) ANTENNAS WITHIN UNITARY BRAIDDIVISIONAL MULTIPLEXING (UBDM)”; and to U.S. non-provisional patent application No. 16 / 459,245, filed July 1, 2019, entitled “SYSTEMS, METHODS AND APPARATUS FOR SECURE AND EFFICIENTWIRELESS COMMUNICATION OF SIGNALS USING A GENERALIZED APPROACH WITHIN UNITARYBRAID DIVISION MULTIPLEXING”; and to U.S. non-provisional patent application No. 16 / 459,245, filed July 1, 2019, entitled “COMMUNICATION SYSTEM AND METHOD USING LAYERED CONSTRUCTION OF ARBITRARY UNITARY”. The disclosure of each of the prior applications, namely U.S. non-provisional patent application No. 16 / 459,262, entitled “MATRICES”, is incorporated herein by reference in its entirety for all purposes.

[0004] Statement as to Federally Sponsored Research or Development

[0005] The U.S. Government has a nonexclusive, irrevocable, royalty-free license to practice this invention and to authorize others to practice this invention for all U.S. Government purposes. TECHNICAL FIELD

[0006] The present invention relates generally to data communications, and more specifically, to techniques for enhancing data communications security using unitary braid divisional multiplexing (UBDM). BACKGROUND

[0007] Wireless communication systems are widely deployed to provide various types of communication services such as voice, packet data, and so on. These systems can utilize modulation techniques that provide high performance for certain wireless environments, such as by dividing the overall system bandwidth into a number of sub-bands (e.g., N s In multiple access communication, multiple user devices transmit signals to a receiver over a single communication channel. These signals are superimposed together to form a combined signal that propagates over the 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 can be a cellular telephone belonging to a different user, and the receiver can be a cellular tower. By separating the signals transmitted by the different user devices, the different user devices can share the same communication channel without interference.

[0008] A transmitter can transmit different symbols by changing the state of a carrier or subcarrier (e.g., by changing the amplitude, phase, and / or frequency of the carrier). Each symbol can represent one or more bits. The symbols can each map to a discrete value in a complex plane, resulting in quadrature amplitude modulation, or by assigning each symbol to a discrete frequency, resulting in 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 an analog signal by a digital-to-analog converter, and then up-converted to a carrier frequency for transmission. When different user devices transmit symbols simultaneously over the communication channel, the sinusoidal waves represented by the symbols are superimposed to form a combined signal that is received at the receiver. SUMMARY

[0009] In some embodiments, a method for implementing a fast UBDM transform includes receiving, via a processor, a first vector (an input vector), and partitioning the first vector to produce a magnitude vector and a sign vector. A second vector comprising 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 to an intermediate sign vector based on an algorithm, and applying a plurality of non-linear layers to the intermediate sign vector to produce the modified sign vector. Optionally, converting the sign vector is based on an initialization vector. Each non-linear layer of the plurality of non-linear layers comprises at least one of a permutation, an S-box transformation, a diffusion linear operation, or an exclusive OR operation, or any combination thereof. 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 transmitting 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 the total power of the first vector.

[0010] In some embodiments, a method for implementing a fast UBDM transform includes receiving, via a processor, an input vector comprising 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., comprising an exclusive OR operation) and a plurality of non-linear 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 further includes sending a signal representing the transformed vector to at least one transmitter for transmitting 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 the total power of the first input vector. BRIEF DESCRIPTION OF DRAWINGS

[0011] Figure 1 is a block diagram illustrating an example electronic communication system in an electronic environment in which the improved techniques described herein can be implemented.

[0012] Figure 2 is a block diagram illustrating a processing flow for encoding and decoding a signal according to an embodiment.

[0013] Figure 3 is a diagram illustrating a system for encoding and decoding a signal according to an embodiment.

[0014] Figure 4 is a flow diagram illustrating an example method of modulating data using a non-linear transform according to an embodiment.

[0015] Figure 5 is a flowchart illustrating an example method for implementing a fast UBDM transform according to an embodiment.

[0016] Figure 6 is a flowchart illustrating an example method for implementing a fast UBDM transform according to an embodiment. DETAILED DESCRIPTION

[0017] When a linear transform is applied to data as part of an encoding (e.g., “pre- encoding”) or modulation process prior to transmission via a network, the transmitted data can be susceptible to decryption by an eavesdropper who can be able to determine the linear transform based on a small number of “plaintext / ciphertext” pairs (e.g., pairs) and using, for example, a single matrix inversion. As such, systems and methods employing linear transforms can be improved by pre-transmission non-linearization of the data. Although known mechanisms exist for applying non-linear operations to complex numbers generally, and although there are data security risks associated with linear transforms, applying such mechanisms in the context of data modulation has been considered previously unperformed successfully, for example, due to various constraints and considerations often 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 amplify the signal and distort it, increasing the bit error rate (BER). Non-linear transforms are not generally isometric, and thus also amplify noise and increase the BER to undesirable levels. In contrast, unitary transforms preserve signal power and are isometric, and thus are used universally in signals without regard for security considerations. Some known cryptography includes non-linear components that can thwart linear attacks by eavesdroppers. However, because such cryptography operates on bits (i.e., bit-level security) rather than on symbols, noise is not a concern.

[0018] Techniques are provided herein for modifying complex baseband symbols in a non-linear manner to enhance security of an orthogonal frequency division multiplexing (OFDM) system. In some embodiments, a method of encoding data includes identifying a plurality of complex number sets (e.g., pairs) of an input data vector, and generating a transformed data vector by applying a non-linear transform to each of the plurality of complex number sets. The non-linear transform includes modifying a phase of a first complex number in each of the plurality of complex number sets. The phase modification is based on a value associated with a second complex number in each of the plurality of complex number sets. A signal representing the transformed data vector is sent to a plurality of transmitters for transmitting the signal representing the transformed data vector from the plurality of transmitters to a plurality of receivers. A signal representing the non-linear transform is sent to a second computing device for transmitting the non-linear transform to the plurality of receivers for recovering the data vector at the plurality of receivers prior to transmitting the signal representing the transformed data vector from the plurality of transmitters to the plurality of receivers.

[0019] As used herein, a "transmitter" (or "signal transmitter") refers to any collection of components used in signal transmission, including but not limited to any combination of one or more of the following: an antenna, an amplifier, a cable, a digital-to-analog converter, a filter, an up-converter, a processor (e.g., to read bits and / or map bits to baseband), etc. Similarly, as used herein, a "receiver" (or "signal receiver") refers to any collection of components used in receiving a signal, including but not limited to any combination of one or more of the following: an antenna, an amplifier, a cable, an analog-to-digital converter, a filter, a down-converter, a processor, etc.

[0020] Some embodiments of the present disclosure include systems and methods that implement a non-linearization of pre-transmission data symbols as part of a modulation process for establishing data privacy at the physical layer without amplifying noise. The non-linear transformations (or "transformations") set forth herein include non-linear transformations that do not amplify noise or introduce minimal amounts of noise amplification. The non-linear transformations can be applied to input data (e.g., data vectors or symbols derived therefrom) one or more times, optionally interleaved any number of times with other transformations (linear or otherwise).

[0021] Figure 1 FIG. 1 is a diagram illustrating an example system 100 in which improved techniques for transmitting wireless communications are performed. The system 100 includes a signal transmitter 120 and a signal receiver 150. However, it should be understood that other signal transmitters not illustrated can be present in the environment.

[0022] The signal transmitter 120 is configured to prepare signals to be transmitted to the signal receiver 150 and transmit the prepared signals to the signal receiver 150. The signal transmitter 120 includes a set of processing circuitry 124, a memory 126, and a transmitting circuitry 128. The set of processing circuitry 124 includes one or more processing chips and / or accessories. 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, etc. The set of processing circuitry 124 and the memory 126 together form a control circuit that is configured and arranged to perform the various methods and functions described herein. The transmitting circuitry 128 is configured to transmit signals in the form of radio frequency energy to a receiver.

[0023] In some embodiments, one or more components of the signal transmitter 120 can be or can include a processor (e.g., the processing circuitry 124) configured to process instructions stored in the memory 126. Examples of such instructions include an initial vector generation manager 130 and a synchronization signal generation manager 146. In addition, as shown in Figure 1 Figure 1 ​As shown in FIG. 1, the memory 126 is configured to store various data, including an initial vector 132, a channel index 136, a signal 140, and a synchronization signal 148.

[0024] Fast unitary transform

[0025] The above methods and systems generally involve matrix operations on vectors. If the length of the vector is N and the size of the matrix is N x N (e.g., when the matrix is a unitary matrix), the matrix operation on the vector involves O(N 2 ) multiplications. Thus, as N increases, the computational burden of the telecommunication system can be prohibitive.

[0026] In some embodiments, some fast unitary transforms can be employed to reduce the computational complexity. For example, the matrix operation on the vector can be implemented using Fourier matrices, Walsh-Hadamard matrices, Haar matrices, skew matrices, certain types of Toeplitz matrices, and certain types of circulant matrices that can operate on vectors in a fast complexity class. However, these types of matrices only form a limited class of transforms, and thus the resulting level of security can not be satisfactory.

[0027] To address the complexity problem while maintaining the security of the communication, the systems and methods described herein employ a method of constructing an arbitrary unitary matrix from smaller matrices. In this method, the unitary matrix is constructed 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. The permutation matrix is a unitary matrix that does not require any floating point operations, and thus is computation-free, i.e., has a complexity of O(l). The U(2) matrix is a matrix with mostly zeros, except for 2 x 2 blocks along the diagonal (also referred to as block-U(2) matrices). These block-U(2) matrices involve only 4 x N / 2 = 2 x N multiplications. As a result, a layer that includes a block-U(2) involves 2 x N multiplications for the block-U(2), and no multiplications for the permutation. In other words, a layer in the construction of the unitary matrix has a complexity of O(N).

[0028] The total complexity of constructing the unitary matrix is the product of the number of layers and the complexity O(N) of each layer. In some embodiments, the total number of layers can be log(N), and thus the total complexity of all the layers is O(N x log(N)), which is comparable to the complexity of standard OFDM. Moreover, the block-U(2) and the permutation of the log(N) layers can produce a dense unitary matrix. Although the space of the fast unitary matrix is not as large as the full space of the unitary matrix, it can still be large enough to deter attacks by eavesdroppers.

[0029] In some embodiments, the methods described herein can employ block-U(M) matrices to construct the unitary matrix, where m is a positive integer (e.g., m = 3, 4, 5, etc.). In some embodiments, matrices of different sizes can also be used within a single layer when constructing the unitary matrix. In some embodiments, different layers can use matrices of 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 than l. For example, if N = 8, then a set of four 2x2 block-U(2) matrices can be used in a first layer, followed by a permutation. Then, in a second layer, two U(3) matrices and a single U(2) matrix can be used, followed by another permutation. A third layer can include a block-U(2) matrix, a block-U(4) matrix, then another block-U(2) matrix, followed by a third permutation.

[0030] In some embodiments, certain types of fast unitary matrices can also be written in layers, each layer including 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, skew matrices, and Toeplitz matrices. In some embodiments, the unitary matrices that can be constructed using the layered approach include any matrix that is not a direct sum of discrete Fourier matrices.

[0031] Security issues with linear transforms in modulation

[0032] To illustrate a security vulnerability related to data modulation using linear transformations, assume that Alice and Bob are at the transmitter and apply a linear unitary matrix A to data symbols Only the linear unitary matrix A is applied to obtain = A Then at the receiver, the A † (i.e., the inverse of matrix A) is applied to obtain A † = A † A = In this case, assume that Eve is able to collect a set of N linearly independent values of , denoted as 1, 2,..., N If Eve knows the corresponding untransformed bits 1,..., N , then she can permute the untransformed bits to the matrix B = ( 1,..., N ), and permute the transformed bits to the corresponding matrix S = ( 1,..., N ). Then the equation linking B and S is

[0033] S = AB (18)

[0034] Thus, since the wavelets are assumed linearly independent and A is assumed unitary, S will be full rank (i.e., all rows and columns are linearly independent), and Eve can easily invert it to get

[0035] A = BS –t (19)

[0036] This gives Eve the entire matrix A, and thus, the security of the data transmission is compromised.

[0037] Non-linear transforms in modulation

[0038] The above example illustrates a potential security breach when linear transformations are used for data modulation. The following sections describe embodiments for nonlinear transformations during data modulation to improve the security of data transmission while avoiding the drawbacks typically associated with nonlinear operations. For example, as described above, nonlinear transformations can amplify signals and / or distort signals, thereby amplifying noise, reducing the signal-to-noise ratio (SNR), and / or increasing the bit error rate (BER). Some embodiments set forth herein achieve a perturbation of linearity (i.e., nonlinearity) in a manner that allows the system designer to adjust the degree of nonlinearity without amplifying (or minimally amplifying) noise. The nonlinear transformations described herein can not increase the total power of the signal and are invertible, thus allowing data recovery at the receiver. The nonlinear transformation can be applied to the input data (e.g., a data vector or symbols derived therefrom) one or several times, optionally interleaved with other transformations (linear or otherwise), prior to transmitting the transformed data. For example, there can be 5 layers of “block U(2)” matrices with nonlinearity (as described herein) and permutation.

[0039] Figure 2is a block diagram illustrating a processing flow for encoding and decoding a signal using a nonlinear transformation, according to an embodiment. During the encoding and decoding process 200, an input data vector "X" is input to a computing device in 202. In 210, a nonlinear transformation, which can optionally be a norm preserving transformation, is applied to the input data vector X via the computing device to produce a transformed vector. In 212, the transformed vector is sent to one or more transmitters for wireless transmission 220. In 222, one or more signals representing the transformed vector are sent to one or more receivers, and once received at the one or more receivers, the transformed vector is decoded / demodulated based on the nonlinear transformation in 230 to reconstruct the input data vector (output "Y") in 232. As indicated by the dashed line in 232, the representation of the nonlinear transformation can have been sent from the computing device to the one or more receivers (e.g., prior to, in parallel with, overlapping in time with, or after the sending of the one or more signals representing the transformed vector to the one or more receivers in 222). Figure 2

[0040] In some embodiments, the nonlinear transformation includes applying a first nonlinear transformation and a second nonlinear transformation prior to sending the signals representing the transformed data vector to the plurality of transmitters. The first and second nonlinear transformations can be applied to a common set or subset of the set of complex numbers, or each can be applied to a different set or subset of the set of complex numbers. For an example of the latter case, assume that the input data vector has a length of 4 and includes components (i.e., complex numbers) 1, 2, 3, and 4. Now, assume that prior to the first nonlinear transformation, components 1 and 2 are paired as one set and components 3 and 4 are paired as another set. Then, for example in time parallel or overlapping, the first nonlinear transformation is applied to the (1, 2) set and the (3, 4) set. Next, another set of sets is identified in which components 1 and 3 are paired as a first set and components 2 and 4 are paired for a second set. Then, for example in time parallel or overlapping, the second nonlinear transformation is applied to the (1, 3) set and the (2, 4) set. Note that in some embodiments, although the first nonlinear transformation can be applied in parallel to the (1, 2) set and the (3, 4) set, and the second nonlinear transformation can be applied in parallel to the (1, 3) set and the (2, 4) set, the first and second nonlinear transformations are not performed in parallel because the input to the second nonlinear transformation is the output from the first nonlinear transformation.

[0041] Example non-linear operation

[0042] In some embodiments, in the first portion of the fast transform, the nonlinear operation Q is applied q times. Each Q i has a vector of length N associated with it, denoted as ​i There are a total of q such vectors. i The value in can be referred to as the "activator" for the fully nonlinear transformation Q. i Each component is a 2-bit value. Therefore, in each i There are a total of 2N bits.

[0043] Q i Actions (depending on) i ) are paired, targeting The adjacency values ​​(i.e., components 1 and 2, then components 3 and 4, etc.). This action can be illustrated with reference to a single 2-component block. If and only if the following condition is satisfied: Given certain conditions regarding the value of b1, Q can include modifications to the second component of each tuple of the vector, in a manner that depends on what those values ​​are. Below is example pseudocode for Q's action on a single tuple. The input is two vector components b1 and b2 (residing in constellation C) and two 2-bit values ​​w1 (with bits w... 11 and w 12 w1 and w2 (with bit w) 21 and w 22 ).

[0044] if w 11 == 0 then

[0045] if (—1) w12 == Sign (Re(b1)) then

[0046] if (w 21 , w 22 ) == (0, 0) || (w 21 , w 22 ) == (1, 1) then

[0047] b2 ← —b2

[0048] end if

[0049] if (w 21 , w 22 ) == (0, 1) then

[0050] b2 ←

[0051] end if

[0052] if (w 21 , w22 ) == (1, 0) then

[0053] b2 ←

[0054] end if

[0055] end if

[0056] end if

[0057] if w 11 == 1 then

[0058] if (—1) w12 == Sign (Im(b1)) then

[0059] if ((w 21 , w 22 ) == (0, 0) || (w 21 , w 22 ) == (1, 1)) then

[0060] b2 ← —b2

[0061] end if

[0062] if (w 21 , w 22 ) == (0, 1) then

[0063] b2 ←

[0064] end if

[0065] if (w 21 , w 22 ) == (1, 0) then

[0066] b2 ←

[0067] end if

[0068] end if

[0069] end if

[0070] The function Sign(x) is a function that returns +1 when x > 0 and -1 when x < 0. For example, consider the case where w1 and w2 are (1; 0) and (1; 1), respectively, and b1 = 1 + i and b2 = -1 + i. Since w 11= 1, therefore consider the imaginary part of b1. The sign of the imaginary part of b1 is Sign (Im(b1)) = Sign (Im(1+i)) = Sign(+1) = +1. Value (-1) w12 = (—1) 0 = +1. Therefore, the situation is (-1). w12 == Sign (Im(b1)). Because w2 = (1, 1), b2 ← —b2, and Q's action on this pair is:

[0071] → (0.1.1)

[0072] Note that the first (upper) component remains unchanged. The aforementioned operations are performed on each pair of vectors, and these operations together constitute a single application of Q. This includes permutations, such that distinct components act as "control gates" for the other components at each of the q layers. Note that the action of Q is unitary, although highly nonlinear.

[0073] In some embodiments, generating the transformed data vector further includes performing a linear transformation or a discrete Fourier transform after applying a nonlinear transformation. Alternatively or additionally, one or more receivers receiving one or more signals representing the transformed vector include multiple antenna arrays, and the receivers(s) and transmitters(s) can be configured to perform multiple-input multiple-output (MIMO) operation.

[0074] Figure 3 This illustrates an embodiment for encoding and decoding signals (e.g., for implementing...). Figure 2 The system diagram for process 200). System 300 includes one or more transmitters (“T”). X 310, each transmitter includes a processor 312 and multiple antennas 314a to 314d. Transmitter 310 is communicatively coupled to one or more receivers (“T”) via a wireless communication network 320. Y330, each receiver includes a processor 332 and multiple antennas 324a to 324c. In 302, an input data vector X is received at the system and transformed into a transformed data vector by a nonlinear transformation, which is then transmitted by transmitter 310 to receiver(s)330 via one or more of antennas 314a to 314d of network 320. In 342, the transformed vector is received at receiver(s)330 via one or more of antennas 324a to 324c and demodulated based on the nonlinear transformation to produce a recovered data vector Y. Each of antennas 314a to 314d can transmit signals to multiple antennas 324a to 324c. In other words, antennas 314a to 314d of receiver 310 and antennas 324a to 324d of receiver 330 can be configured as follows: Performing Multiple-Input Multiple-Output (MIMO) operation: Antenna 314a of transmitter 310 can transmit signals via wireless communication network 320 to one, a subset, or all of antennas 324a, 324b, and 324c of receiver 330 (as signals 322a, 322b, and 322c, respectively). Similarly, antenna 314b of transmitter 310 can transmit signals via wireless communication network 320 to one, a subset, or all of antennas 324a, 324b, and 324c of receiver 330 (as signals 322d, 322e, and 322f, respectively), and antenna 314c of transmitter 310 can transmit signals via wireless communication network 320 to one, a subset, or all of antennas 324a, 324b, and 324c of receiver 330 (as signals 322g, 322h, and 322i, respectively).

[0075] Figure 4 This is a flowchart illustrating an example method for modulating data using a nonlinear transformation according to an embodiment. Figure 4 As shown, method 400 includes: in 410, identifying a plurality of complex numbers of an input data vector via a processor of a first computing device. The input data vector includes a plurality of complex numbers. In 420, generating a transformed data vector by applying a nonlinear transformation to each subset of the plurality of complex numbers. The nonlinear transformation includes modifying the phase of a first complex number in the set of complex numbers based on a value associated with a second complex number in the set of complex numbers. In 430, transmitting a signal representing the transformed data vector to a plurality of transmitters for transmitting the signal representing the transformed data vector from the plurality of transmitters to a plurality of receivers. In 440, transmitting a signal representing the nonlinear transformation to a second computing device for transmitting the nonlinear transformation to the plurality of receivers before, simultaneously, temporally overlapping, or after transmitting the signal representing the transformed data vector to the plurality of receivers, for recovering the data vector at the plurality of receivers.

[0076] In some embodiments, modifying the phase of the first complex number in the set of complex numbers is also based on a predetermined factor, and the method 400 further comprises transmitting a signal representing the predetermined factor to the plurality of receivers for recovering the data vector at the plurality of receivers, prior to, concurrently with, overlapping in time with, or after transmitting the signal representing the transformed data vector from the plurality of transmitters to the plurality of receivers.

[0077] In some embodiments, the input data vector comprises a plurality of complex numbers that are split or decomposed into their "norm" (or "magnitude") and phase components. For example, each complex number z can be written as:

[0078] z = r e i*x ,

[0079] where r is a positive real number and x is a real number within [0, 2pi).

[0080] A plurality of complex numbers is divided or decomposed into a set of complex numbers (e.g., a detected or selected plurality of sets of complex numbers), and a difference between two norms of each set of complex numbers is calculated. If r1 is the norm of one of the two complex numbers and r2 is the norm of the other complex number, 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. This intermediate value is then multiplied by a predetermined constant R to obtain a value: R*(r1 - r2)*p or R*(r2 - r1)*p. This value is then used to define the angle by which the phase of the original complex number (z1 or z2) with the smaller norm is rotated / adjusted.

[0081] As an example, given a set of complex numbers as follows:

[0082] z1 = r1 * e {i x1}

[0083] z2 = r2 * e {i x2}

[0084] Assuming r2 < r1, the phase of z2 is adjusted while z1 remains unchanged, as follows:

[0085] z1 = r1 * e {i x1}

[0086] z2 = r2 * e {i x2} * e {i R*(r1 -r2)^p}

[0087] In other words, complex numbers with smaller magnitude rotate in the complex plane by an angle proportional to the power of the difference between the magnitude of the complex number and the magnitude of the complex numbers in the set (i.e., a non-linear transformation). Simulations show that for any N (N is the number of subcarriers) and for any underlying constellation, there exist values of p and R that make it impossible for an eavesdropper to attempt any linear attack, while the impact on the BER can be negligible (at most a cluster variance of less than half a dB for real SNRs). A "constellation" (or constellation diagram) is a representation of a signal modulated by a digital modulation scheme.

[0088] In some embodiments, the values of R and p are different for each set of symbols in each baud. For example, R can be a function of which "layer" (e.g., in the sense described above, where a "layer" consists of a block-U(2) and a permutation, as described above) and / or which set of symbols is being operated on.

[0089] In some embodiments, the non-linear transformation can be performed at any stage of the precoding or pre-transmission operation and / or on any set 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 the precoding or pre-transmission operation, once at the end of the precoding or pre-transmission operation, once between each block-U(2) and permutation (i.e., after a block-U(2) and before a permutation), and so on. The non-linear transformation can be interleaved with any number and combination of other precoding operations, whether those other precoding operations are linear or non-linear. In some embodiments, the non-linear transformation is applied to all sets of complex numbers of the input vector. In other words, each complex number is combined with another complex number, for a total of N / 2 sets. In other embodiments, the non-linear transformation is only applied to a subset of the sets of complex numbers of the input vector, and not to other sets of complex numbers of the input vector.

[0090] In some embodiments, the non-linear transformation is performed as follows. Take both components of the full (Length-N) baud. Both components can be complex numbers, so they can be written as:

[0091] = (20)

[0092] For the purposes of discussion, a single 2-vector is given above, however other vector lengths / sizes can be used (e.g., a single 3-vector, a single 4-vector, multiple vectors, etc.). The following operations can be performed on any two components of a vector, and the two components do not have to be adjacent to each other. In some implementations, a few layers of "fast UBDM" layers are applied first, followed by a permutation, then a non-linear transformation is applied to each vector set (e.g., this is when the sets are adjacent or "side-by-side" because the vector sets are permuted and mixed several times by the layers), followed by one or more additional "fast" layers. Other examples of fast UBDM layers are described below.

[0093] To perform a non-linear transformation on a single component set (e.g., on ), two parameters can be chosen: 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 two complex numbers, the one with the smaller magnitude is rotated by an angle proportional to the difference between the two absolute values. The smallest rotation will occur when (r1−r2) = 0, which will result in a rotation of 0. The largest rotation will occur when (r1−r2) is the largest possible distance, which will depend on the constellation used.

[0094] For each complex number set as in (20), the difference (r1−r2) is computed, raised to the power p, and multiplied by R to produce a value that defines the degree of phase rotation to be applied to the complex number with the smaller magnitude. In other words, the following phase shift is computed:

[0095] = R(r1−r2) p

[0096] This expression is 0 when r1= r2. As (r1−r2) increases, so does ϕ, and the power p controls the rate at which ϕ grows. Once ϕ is computed, the complex number with the smaller magnitude is multiplied by e iϕ . For example, assume in (20) that r 1 > r 2 . The transformation will be:

[0097]

[0098] The receiver goes through a similar process, except that once the receiver computes ϕ, it rotates the complex value with the smaller magnitude in the opposite direction.

[0099] Fast unitary butterfly demultiplexing (UBDM) transform

[0100] SUMMARY

[0101] Consider a constellation that includes "Bose-Chaudhuri-Hocquenghem" (BCH) vectors basic input, "Pott" vector 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 = (1 + i, -1 + i, -1 + i, -1 - i).

[0102] In some embodiments, applying a "fast" UBDM transform (or "transformation") to an example vector includes applying a non-linear portion (i.e., a non-linear "transformation") followed by a linear portion (i.e., a linear "transformation"). Each of the non-linear portion and the linear portion is "keyed" and implemented using a shared secret between Alice and Bob, which is in the form of a bit sequence. The non-linear portion includes performing a non-linear operation on the sign bits of one or more input Pott vectors, as well as performing a permutation of the magnitudes. During the non-linear portion, the magnitudes can be permuted without any other change to the magnitudes, e.g., to preserve the total power of the Pott vectors. The non-linear operation on the sign bits can have the effect of mimicking a block cipher, and thus can include all of the non-linearity of the UBDM transform. As described below, the non-linear portion and the linear portion can operate in "layers." The number of layers in each of the non-linear portion and the linear portion, denoted as L, can vary depending on the application, and the number of layers associated with the non-linear portion can be the same as or different from the number of layers associated with the linear portion. For example, in some embodiments, the number of linear layers is L = [log2(N)], and the number of non-linear layers, denoted as Q, varies depending on the performance constraints and security constraints of the overall communication system, and can have a value between Q = 0 (least secure) and Q = ⌈log2(N)⌉ (more secure).

[0103] In some embodiments, the linear layers are in the form of:

[0104] , (1.1.1)

[0105] where P is a permutation matrix, and U is a direct sum of U(2) matrices.

[0106] Non-linear operation

[0107] In some embodiments, the nonlinear operation (i.e., the nonlinear portion of the fast UBDM transform) includes multiple one-off steps and a series of nonlinear and / or linear layers. The multiple one-off steps can include one or more operations from the general class of operations, such as including S-box application, diffusion linear transform (e.g., a Maximum Distance Separable (MDS) matrix), XOR addition, permutation, etc. In some embodiments, the nonlinear operation (i.e., the nonlinear portion of the fast UBDM transform) includes multiple operation applications typically found in block ciphers (a general class of symmetric cryptography), including (but not limited to) Substitution-Permutation-Network (SPN) structure, Feistel structure, Lai-Massey structure, S-boxes of arbitrary size, key XOR addition, diffusion linear transform, permutation, Add-Rotate-XOR (ARX) operations, etc. These operations can be applied to the complex-valued numbers themselves, the sign values, the magnitude values, or any combination, in order to alter the magnitude, frequency, and phase of various components of the signal waveform. The input is a bote vector and a plurality of shared secrets. If the number of nonlinear layers is Q and there are N subcarriers, then for any number of bits (e.g., 4 bits or 8 bits), the shared secrets include Q+1 permutations of length 2N, Q+1 strings of bits of length 2N, and a substitution box (“S-box”) of a symmetric key algorithm. Optionally, there can also be an initialization vector that is a string of bits of length 2N. The generation, storage, and transmission of each of these elements is discussed below.

[0108] In some embodiments, the nonlinear operation is applied as follows. First, given a bote vector , the bote vector is partitioned (i.e., decomposed or split) into its 2N (real and imaginary) magnitudes and its 2N sign bits. For example, if the initial bote vector comes from a 16-state quadrature amplitude modulation (16-QAM) constellation and is = (3 - i, 1 + i, -1 + 3i, 1 + i), then the magnitude and sign vectors are:

[0109] (3, 1, 1, 1, 1, 3, 1, 1)

[0110] and

[0111] (+1, -1, +1, +1, -1, +1, +1, +1).

[0112] For the magnitude vector , a single permutation P m is applied to the elements (optionally, without any other modification to the magnitude vector ). Next, for the sign vector , the elements are treated / handled as bits, and an algorithm similar to a very small block cipher is applied to produce an intermediate symbol vector (or "intermediate vector"). For example, one such implementation is to convert the vector to bits as follows:

[0113] = (0, 1, 0, 0, 1, 0, 0, 0).

[0114] The modified symbol vector above may be referred to as an intermediate symbol vector (or "intermediate vector"). The type of modification applied to the symbol vector can be selected based on the mode of operation. Examples of modes of operation include, but are not limited to: Electronic Codebook (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 individually. 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 ciphertext before encryption. CTR is a mode of operation in which a block cipher is used to encrypt successive values of some kind of "counter," and the output bit stream is XORed with data to create a 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 of the next block. This will create a bit stream that can be XORed with plaintext to create a cipher. CFB is a mode of operation in which a block cipher is used to encrypt an initial random value, which is then XORed with plaintext to create a cipher. This cipher is then fed directly into the encryption of the next block, which is then XORed with the next block of data, and so on.

[0115] For example, in some embodiments, if the mode of operation is CBC mode, then the symbol vector is XORed with a bit vector of length 2N (i.e., an initialization vector (IV), which is part of the shared secret). However, if the mode of operation is ECB mode, then the IV can not be applied. Instead, the first step in ECB mode (or the second step in CBC mode) can be to XOR the symbol vector with a "seed" vector of binary vectors of length 2N. This seed vector of length 2N can be referred to as a bit vector .

[0116] Next, a nonlinear "layer" 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 here as ). The bit vector is referred to as a "seed," while the term ,..., referred to as "activators". Applying each nonlinear layer includes applying a permutation P q , followed by an S-box transformation on blocks of 4 bits or blocks of 8 bits, followed by an XOR operation on the symbols of the layer.

[0117] In some embodiments, once all nonlinear layers have been applied, and if the system is in CBC mode, the resulting vector of symbols is saved and subsequently used as the initialization vector for the UBDM transformation of the next block of symbols to be transformed.

[0118] An example pseudo code for nonlinear transformation in ECB mode is provided below. Given a vector of constellation points of length N and a shared secret P m , , for q [1,...,Q] and P q for q [1,...,Q], the input to the algorithm is a block of symbols .

[0119]

[0120]

[0121]

[0122]

[0123] FOR

[0124]

[0125]

[0126]

[0127]

[0128] The output of the algorithm is the transformed value (also referred to herein as the modified vector of symbols).

[0129] An example pseudo code for nonlinear transformation in CBC mode is provided below. Given a vector of constellation points of length N and a shared secret , P m , ,​ (for q [1,...,Q]) and P q (for q [1,...,Q]), the input to the algorithm is the port and the constellation vector .

[0130]

[0131]

[0132]

[0133]

[0134]

[0135] FOR

[0136]

[0137]

[0138]

[0139]

[0140]

[0141] The output of the algorithm is the transformed value and a new initialization vector This new initialization vector will be the input to the next port vector to be transformed.

[0142] In some embodiments, when the mode of operation is ECB mode and the algorithm is applied to the same port vector twice, the same output will be obtained both times. In other embodiments, when the mode of operation is CBC mode, since the initialization vector is used (and thus incorporated) in each transformation, different outputs can be obtained when performing the transformation on successive port vectors, even if the inputs are the same, thus providing an additional obstacle for a potential attacker to overcome and increasing the information security.

[0143] Once the above nonlinear operation has been completed, the linear / unitary portion of the "fast" UBDM transformation is performed on the output of the nonlinear operation, as follows.

[0144] Example block U(2) operation

[0145] In some embodiments, the action U is performed on a pair of vectors resulting from a previous linear or nonlinear operation. The action U implements a unitary "mixing" of the components. A single 2x2 block can be of the following form:

[0146] (1.3.1)

[0147] Along a single matrix The diagonal can include a total of N / 2 (1.3.1) 2x2 blocks, and can include 2N complex numbers (where N is the UBDM block size, and if the system is OFDM, N can refer to the number of subcarriers). To improve the efficiency and speed of data retrieval, in some implementations, only the angle is stored. Instead of storing the complete complex number, θ and ϕ are stored. This means fewer bits (e.g., at least 8 bits per angle) can be used to store each of the aforementioned angles compared to storing the complete complex number. Therefore, for storage purposes, each U may only require 4 bits. 8 (N / 2) = 16N bits. When it comes to the actual complex floating-point time used in calculating the matrix, if, for example, the 8-bit value of θ is an integer m (where m is an integer)... Then θ can be set as θ = Radius. 4 angles ( Each of ,θ and ϕ can be calculated in this way to the required number of decimal places.

[0148] For the two components of the Bode vector The actions are as follows:

[0149] (1.3.2)

[0150] For each pair of components of the vector generated by the nonlinear operation, U operates as shown above. The permutation following each U is used to mix / combine as many different components as possible in an unpredictable manner.

[0151] The following is an example pseudocode for the permutation after each U. Given an initial vector (As the output of the above nonlinear steps), and the permutation P l (For l) The set of [1,..., L] and block U(2) matrix U, perform the following operations:

[0152]

[0153]

[0154]

[0155]

[0156] In the above pseudo-code, U denotes the set of all block U(2) matrices of each layer. Thus, U[l], where l [1,..., L] denotes the l-th layer block-diagonal U(2) matrix. U[l][b], where b [1,..., N / 2] denotes the b-th 2x2 U(2) block along the diagonal of the l-th layer matrix. The notation of the permutation P l is in "list" format. For example, P l = (3,1,4,2) is a 4-element permutation, where each value specifies the resulting index for that element.

[0157] Example permutation operation

[0158] Various different permutations can be used for both the non-linear portion of the fast UBDM transform and the linear portion of the fast UBDM transform. An example efficient method for generating and storing such permutations is given below.

[0159] Note that for N objects, there are N! unique permutations. In other words, if one defines a mapping from the integers [0, N!) to such permutations, one can randomly generate one such integer, and then map it to the corresponding permutation using, for example, a Lehmer code. Lehmer codes facilitate the conversion (or mapping) of permutations to integers and integers to permutations in a fast and efficient manner. An example of mapping integers to permutations is discussed below.

[0160] Suppose N = 4. Given that 4! = 24, there are 24 permutations, which can be labeled with the integers 0...23. One can first randomly select one of these integers. Suppose the selected integer is 17. Next, convert this integer from base-10 to "base-factorial", for example, as follows:

[0161] (1.4.1)

[0162] (1.4.2)

[0163] (1.4.3)

[0164] (1.4.4)

[0165] When the quotient is 0 (optionally with the remainder), the conversion terminates. Then use the remainder value to obtain the factorial expression, as follows:

[0166] (1.4.5)

[0167] Once the factorial representation of an integer is obtained (which can be written as (2,2,1,0)), the following algorithm is executed. The process starts with the rightmost component and moves left. At each step, each value to the right of the considered component is incremented by 1 if and only if it is equal to or greater than the considered component. For the example above:

[0168] (2,2,1, 0 ) no action

[0169] (2,2, 1 ,0) no action

[0170] (2, 2 ,1,0) no action

[0171] ( 2 ,2,1,0) increment the second component because it is equal to the value underlined

[0172] (2,3,1,0) (1.4.6)

[0173] The last item in the above list, (2,3,1,0), represents the permutation. Each element in the permutation corresponds to a column in P, and the position in each column of P is the position 0, 1, 2, and 3 in the vertical direction downwards. It represents that the first element moves to position 2, the second element moves to position 3, the third element moves to position 1, and the last element moves to position 0. The matrix representation of this permutation is:

[0174] (1.4.7)

[0175] Consider another example where the integer is 8. The factorial representation is:

[0176]

[0177]

[0178]

[0179]

[0180] So, in fact:

[0181] (1.4.8)

[0182] Next,

[0183] (1,1,0, 0 ) no action

[0184] (1,1, 0,0) we add 1 to the last 0

[0185] (1, 1 ,0,1) the last 1 is unchanged, but we add 1 to the last 1

[0186] ( 1 ,1,0,2) both the second 1 and 2 are incremented by 1

[0187] (1,2,0,3). (1.4.9)

[0188] This corresponds to the permutation matrix:

[0189] (1.4.10)

[0190] In some embodiments, to generate a permutation 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. For example, the number of bits used to hold an integer between 0 and N! - 1 can be determined using the Sterling approximation, which in some implementations can provide a slight overestimation. Then, rather than first converting the resulting bit string to an integer and then converting that integer to its base factorial form, the number of bits for each value can be approximated directly. Note that the form of a general number in base factorial is:

[0191] (1.4.11)

[0192] The value a n is between 0 and n, and represents the number of bits to read for each value. As an example, assume N = 8. The approximate number of bits to read is then:

[0193] (1.4.12)

[0194] Next, consider a list of 16 random bits (e.g., using a pseudo-random number generator, such as the PRNG function in mathematics):

[0195] (0,0,1,0,0,0,1,0,1,0,0,1,0,1,1,0)

[0196] The first item in the above list of 16 random bits is the coefficient 0!, which is 0, so that item can be ignored. The second item in the above list of 16 random bits is the coefficient 1!, which is either 0 or 1. Given the first bit above (in this case, the leftmost bit), which is 0, = 0. Then, the first bit is truncated (removed) from the list of 16 random bits, leaving the following list of 15 bits:

[0197] (0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0)

[0198] Next, the value of is obtained. This value can be 0, 1, or 2, so, it is represented by 2 bits. Since 2 bits can store 3 or more possible values, consider the value mod 2+1=3. The next 2 bits (the leftmost 2 bits in the above 15-bit list) are 0 and 1, which have a value (when concatenated, i.e., "01") of 1, so is set to =1. Again, truncate (remove) the first 2 bits from the above 15-bit list, leaving the following 13-bit list:

[0199] (0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0)

[0200] Next, for , the value can be 0, 1, 2, or 3, so, it is represented by 2 bits. The first 2 bits (the leftmost 2 bits in the above 13-bit list) are 0 and 0, which have a value (when concatenated, i.e., "00") of 0, so is set to =0. Again, truncate (remove) the first 2 bits from the above 13-bit list, leaving the following 11-bit list:

[0201] (0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0)

[0202] Next, for , the value can be 0, 1, 2, 3, or 4, so, it is represented by 3 bits. The next 3 bits (the leftmost 3 bits in the above 11-bit list) are (0, 1, 0), which have a value (when concatenated, i.e., "010") of 2, so is set to =2. Truncate (remove) the first 3 bits from the above 11-bit list, leaving the following 8-bit list:

[0203] (1, 0, 0, 1, 0, 1, 1, 0)

[0204] Next, for , there are 6 values, so, it is represented by 3 bits, which in this example (reading the leftmost 3 bits in the above 8-bit list) is (1, 0, 0) or 4. So =4, and truncate (remove) the first 3 bits from the above 8-bit list, leaving the following 5-bit list:

[0205] (1, 0, 1, 1, 0)

[0206] Next, represented by 3 bits, in this example (reading the leftmost 3 bits in the above 5-bit list) is (1, 0, 1) or 5, so = 5. Truncate (remove) the first 3 bits from the above 5-bit list, leaving the following 2 bits:

[0207] The number of bits needed for a permutation of size N =

[0208] When N = 8, the formula 1.4.13 produces the value 17. The original random bit string with the additional bits (now length 17) is:

[0209] (0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1),

[0210] As described above, the basic factorial number (5, 5, 4, 2, 0, 1, 0, 0) is produced. Applying the permutation to the basic factorial number produces:

[0211] (5, 5, 4, 2, 0, 1, 0, 0)

[0212] (5, 5, 4, 2, 0, 1, 0, 1)

[0213] (5, 5, 4, 2, 0, 1, 0, 2)

[0214] (5, 5, 4, 2, 0, 2, 1, 3)

[0215] (5, 5, 4, 2, 0, 3, 1, 4)

[0216] (5, 5, 4, 2, 0, 3, 1, 5)

[0217] (5, 5, 4, 2, 0, 3, 1, 6)

[0218] (5, 6, 4, 2, 0, 3, 1, 7) (1.4.14)

[0219] Note that the last (bottom) row is the effective permutation on 8 objects.

[0220] In some embodiments, the permutation is reversed, for example as follows. First, the permutation is arranged in the first row, and the associated integers are arranged in the second row below the first row in consecutive order. For the example above, these rows are shown as follows:

[0221] (1.4.15)

[0222] Next, the columns are rearranged so that the top row is sequential, with the result as follows:

[0223] (1.4.16)

[0224] 1.4.16's bottom row is the inverse permutation. This result can be verified by examining the corresponding matrix. The matrix corresponding to (5, 6, 4, 2, 0, 3, 1, 7) (using the above convention) is:

[0225] (1.4.17)

[0226] The inverse permutation (4, 6, 3, 5, 2, 0, 1, 7) corresponds to the matrix:

[0227] (1.4.18)

[0228] It is clear from observing 1.4.17 and 1.4.18 that these matrices are inverses of each other (i.e., one is the transpose of the other).

[0229] Modifications for peak-to-average power ratio (PAPR) reduction

[0230] In some embodiments, modifications are performed to the fast UBDM transform such that PAPR is reduced. Implementing such modifications can involve one or more minor changes to the algorithm, but the total number of generator bits and their usage can be substantially the same. Examples of making such changes to the algorithm are outlined below.

[0231] PAPR reduction in nonlinear transform

[0232] In one or more embodiments, modifications are performed to the nonlinear portion of the fast UBDM transform when using APSK constellations, for example because the non-square nature of APSK constellations can result in undesirable bulges under UBDM. For example, consider the points and where In a square constellation, the value a + ai can also be part of the constellation. Circular APSK constellations specifically avoid such "edge" constellation points. However, when performing the fast UBDM transform described here, the permutation in the magnitude transform in the nonlinear portion of the transform can include swapping the points and to and The point will generally have a larger magnitude than either of or and the overall PAPR will therefore be increased. To avoid or mitigate this effect, the way the magnitude vector transform is performed in the nonlinear transform can be modified, as shown in the following examples.

[0233] Consider the case where N = 4. The magnitude permutation is defined by a permutation of length 2N = 8. For example, the permutation can be (2, 4, 1, 5, 3, 8, 6, 7). The permutation is first split into two lists of length N: the first list where each element is less than or equal to N, and the second list where each element is greater than N, without changing the order of appearance of the elements with respect to the permutation. In the current example, the two lists are (2, 4, 1, 3) and (5, 8, 6, 7). Note that the first list in these lists is a valid permutation of N elements. Next, the "upper half" (5, 8, 6, 7) is reduced modulo 2, resulting in the following modified second list: (1, 0, 0, 1).

[0234] In some embodiments, when performing the non-linear portion of the fast UBDM transform, we use these two vectors (i.e., the first list and the modified second list) to modify the constellation vector. Assume the original constellation vector is:

[0235] (1.5.1)

[0236] Then the magnitude vector of length 2N will be ( , , , , , , , ). Note that the absolute value notation (e.g., the lines in ) is omitted above to avoid cluttering the notation, however, the magnitude vector includes the magnitude of the real and imaginary parts, not just the real and imaginary parts. In the fast UBDM transform process described above, a permutation of length 2N will be applied to the constellation vector. However, in the PAPR reduction transform, the following will be performed:

[0237] First, the magnitude vector is split into 2's blocks, pairing the real and imaginary parts of each number. In this way, the magnitude vector becomes the split magnitude vector ( , ), ( , ), ( , ), ( , ). The split magnitude vector is then acted upon using the length N permutation that results from the original length 2N permutation. In this case, the length N permutation is (2, 4, 1, 3), so the split magnitude vector becomes the permuted split magnitude vector ( , ), ( , )). Next, using the binary vectors resulting from the above vectors, one gets the following (

[0238] The above is then rearranged into vectors:

[0239] (1.5.2)

[0240] The sign of each number in vector 1.5.2 can be determined using a process similar to the example non-linear operation on the sign bits during the fast UBDM transform discussed above. In some embodiments, when PAPR reduction is desired and / or an APSK constellation is being used, the aforementioned modification to the non-linear portion of the fast UBDM transform is used.

[0241] PAPR reduction in linear transform

[0242] In one or more embodiments, modifications are performed to the linear / unitary portion of the fast UBDM transform, for example to limit the values of 0 in the port vector (1.3.2). In the above block U(2) operation portion, the angle bits are used to select an angle from a uniform distribution over To reduce PAPR, for example by selecting values , the value of this angle can be scaled to be close to 0. The closer the value r is to 1, the greater the PAPR will be. If r = 0, then the PAPR will be the same as the original PAPR, especially in the case where the constellation is QAM. If the constellation is APSK, then modifications to the non-linear portion of the fast UBDM transform described in the previous section can also be performed. In some embodiments, a value of r =.01 is desired. Values outside the interval [0,1] are also acceptable.

[0243] Once the value of r is selected, the value θ selected by the generator bits is changed to:

[0244] (1.5.3)

[0245] Then, one can use ​​​​​​​​​​​​The above changes can be implemented without modifying the resulting generator bits. In other words, the same generator bits can be used, but the theta values are scaled in each U(2) block.

[0246] MEM spreading

[0247] In some embodiments, a “MEM” operation is performed during the nonlinear portion of the fast UBDM transform. The MEM operation includes taking a sign vector , treating it as a binary vector (e.g., = (1,1,0,1,1,1,0,0) instead of (–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 string is the number of symbols that are different from the zero symbol of the alphabet being used. Here are a few examples:

[0248]

[0249]

[0250]

[0251]

[0252] Alternatively, if the sign vector is represented as then the operation can be as follows:

[0253] (1.6.1)

[0254] where returns the number of times it occurs in . For example, the MEM operation can be used to maximize the spread quickly and efficiently.

[0255] Example non-linear transform

[0256] Here is an example implementation of the nonlinear portion of the fast UBDM transform according to one or more embodiments. Consider a 16−QAM block:

[0257] (0.-1.1)

[0258] As can be observed in (0-1.1), in this example, the block size is N=4.

[0259] First, the block is divided or split into two separate vectors of length 2N - 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:

[0260] (0.-1.2)

[0261] For the magnitude vector, a permutation is applied, which depends on the generator bit / key value. For example, the permutation "p" can be:

[0262] (0.-1.3)

[0263] Applying the permutation (0-1.3) to the magnitude vector yields the following new magnitude vector:

[0264] (0.-1.4)

[0265] Note that the value originally in the 6th position has moved to the 1st position, the value originally in the 2nd position remains in the 2nd position, the value in the 4th position has moved to the 3rd position, and so on.

[0266] Next, a block cipher is applied to the sign bits. For example, the sign values can be converted to bits as follows:

[0267] (0.-1.5)

[0268] In this example, a "substitution-permutation network" (SPN) cipher is used, however other types of block ciphers are also applicable (e.g., Feistel cipher, Lai-Massey cipher, etc.).

[0269] The sign bits of (0.-1.5) are XORed with the generator / seed value. For example, the seed value can be (1,0,0,1,1,1,1,0). The output of the XOR operation is:

[0270] (0.-1.6)

[0271] Next, a "substitution box" or "S-box" is applied. Applying an S-box involves replacing a set of bits of a predetermined 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:

[0272]

[0273]

[0274] ​

[0275]

[0276]

[0277]

[0278]

[0279] (0.-1.7)

[0280] To apply the S-box, the bit string (1, 1, 1, 1, 0, 0, 1, 0) of (0.-1.6) is broken into chunks, each of four bits. The chunks are (1, 1, 1, 1) and (0, 0, 1, 0). Using the S-box, one can observe that (1, 1, 1, 1) → (0, 1, 0, 1) and (0, 0, 1, 0) → (0, 0, 1, 0).

[0281] Thus, the bit string is now:

[0282] (0.-1.8)

[0283] Next, a permutation is applied to the bit string. For the current example, the permutation = (1, 3, 5, 7, 2, 4, 6, 8), the bit string becomes:

[0284] (0.-1.9)

[0285] Then, the above process is repeated by XORing another 8-bit string, applying the S-box, then applying the permutation, and so on. Finally, the final 8-bit string is obtained and converted back to symbols, e.g., as follows (note that the following does not reflect any repetitions of the transformation):

[0286] (0.-1.10)

[0287] The vector (0.-1.10) is then combined with the permuted magnitude vector and the complex vector of length N is reassembled:

[0288] (0.-1.11)

[0289] The vector (0.-1.11) is the vector of the constellation point, which is subsequently passed to the linear / unitary part (layer / round) of the fast UBDM transform.

[0290] The above repetition (XOR -> S-box -> permutation) can be referred to as a "round" or "layer". The XOR value can be referred to as a "round key", "seed", or "activator". In some embodiments, the same S-box is applied in each of the multiple layers. In other embodiments, a different S-box is applied in each of the multiple layers. In other embodiments, two or more different S-boxes can be used within the multiple layers. The permutation can be the same for each round / layer or different each time. Similarly, in some embodiments, the same permutation is used in each of the multiple layers. In other embodiments, a different permutation is used in each of the multiple layers. In other embodiments, two or more different permutations are used within the multiple layers.

[0291] Each of the number of layers / rounds, the actual value of the XOR value (seed / generator), and the value of the S-box can be variable and / or predefined. Each of the number of layers / rounds, the actual value of the XOR value (seed / generator), and the value of the S-box can be variable and / or predefined whether they are keyed or fixed. While in the above example, the block size is N = 4, and thus the length of and is 8, the size of the block can be variable and / or predefined. While in the above example, the size of the S-box is 4, the size of the S-box can be variable and / or predefined and can be any of a variety of sizes (e.g., 8). While examples are provided above, the order and manner in which the permutation, S-box, addition, etc. are stacked / implemented can be variable and / or predefined.

[0292] Figure 5 is a flowchart illustrating an example method 500 for implementing a fast UBDM transform according to an embodiment. As Figure 5As shown, the method 500 includes receiving, via a processor, a first vector in 510, and partitioning the first vector to produce a magnitude vector and a sign vector in 512. A second vector comprising a modified magnitude vector and a modified sign vector is generated in 514 by: applying a permutation to the magnitude vector to produce the modified magnitude vector in 514A; converting the sign vector to an intermediate sign vector based on an algorithm in 514B; and applying a plurality of non-linear layers to the intermediate sign vector to produce the modified sign vector in 514C. The conversion of the sign vector in 514B is optionally based on an initialization vector. As discussed herein, each non-linear layer of the plurality of non-linear layers comprises at least one of a permutation, an S-box transformation, a diffusion linear operation, or an exclusive-OR operation, or any combination thereof. In 516, 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. For example, in 518, a first signal representing the third vector is sent to at least one transmitter for sending 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 the total power of the first vector. The magnitude vector and the sign vector. In 514, a second vector comprising 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 in 514A; converting the sign vector to an intermediate sign vector based on an algorithm in 514B; and applying a plurality of non-linear layers to the intermediate sign vector to produce the modified sign vector in 514C. The conversion of the sign vector in 514B is optionally based on an initialization vector. As discussed herein, each non-linear layer of the plurality of non-linear layers comprises at least one of a permutation, an S-box transformation, a diffusion linear operation, or an exclusive-OR operation, or any combination thereof. In 516, 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. For example, in 518, a first signal representing the third vector is sent to at least one transmitter for sending 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 the total power of the first vector.

[0293] In some embodiments, the method 500 further includes selecting an algorithm based on an encryption operation mode of the processor. The algorithm can include an exclusive-OR operation, and the encryption operation mode of the processor can be a cipher block chaining (CBC) mode or an electronic codebook (ECB) mode. The number of non-linear layers in the plurality of non-linear layers can be the same as or different from the number of linear layers in the plurality of linear layers.

[0294] In some embodiments, at least one of the number of linear layers in the plurality of linear layers (“L”) or the number of non-linear layers in the plurality of non-linear layers (“Q”) is equal to [log2(N)].

[0295] In some embodiments, at least one of the number of non-linear layers in the plurality of non-linear layers or the number of linear layers in the plurality of linear layers is based on performance constraints and / or security constraints (e.g., of a given communication system or component thereof).

[0296] Figure 6 is a flowchart illustrating an example method 600 for implementing a fast UBDM transform according to an embodiment. As shown in Figure 6 Method 600 includes, in 620, receiving, via a processor, an input vector comprising a plurality of complex numbers. In 622, generating, via the processor, a transformed vector based on the input vector by: applying, in 622A, a permutation to a magnitude vector associated with the input vector to produce a modified magnitude vector; applying, in 622B, an algorithm (e.g., comprising an exclusive-OR operation) and a plurality of non-linear 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, in 622C, a plurality of linear layers to the intermediate vector to produce the transformed vector. Method 600 further includes, in 624, sending a signal representing the transformed vector to, for example, at least one transmitter for transmitting 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 the total power of the input vector.

[0297] In some embodiments, each non-linear layer in the plurality of non-linear layers comprises at least one of a permutation, an S-box transform, a diffusion linear operation, or an exclusive-OR operation. Method 600 can further include selecting the algorithm based on a processor-based encryption mode of operation (e.g., cipher block chaining (CBC) mode or electronic codebook (ECB) mode).

[0298] The number of non-linear layers in the plurality of non-linear layers can be the same as or different from the number of linear layers in the plurality of linear layers. At least one of the number of non-linear layers in the plurality of non-linear layers or the 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.

[0299] In some embodiments, at least one of the number of linear layers in the plurality of linear layers (“L”) or the number of non-linear layers in the plurality of non-linear layers (“Q”) is equal to [log2(N)].

[0300] 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 certain events and / or processes are described as occurring in certain order, it should be understood that the ordering is merely example, and certain events and / or processes can be modified to occur in a different order without departing from the scope of the embodiments. While various embodiments have been illustrated and described, it will be understood that various changes can be made without departing from the scope of the embodiments. Furthermore, where possible, certain steps can be performed in parallel, concurrently, or in any order, without departing from the scope of the embodiments. Additionally, although various embodiments have been described as having particular features and / or combinations of features, other embodiments are also possible having a combination of any features from any of the embodiments described herein. Furthermore, although various embodiments have been described as having particular entities associated with particular computing devices, in other embodiments, different entities can be associated with other and / or different computing devices.

[0301] The systems and methods described herein are intended to be performed by software (stored in memory and / or executing on hardware), hardware, or a combination thereof. Hardware modules can include, for example, general processors, field-programmable gate arrays (FPGAs), and / or application-specific integrated circuits (ASICs). Software modules (executing on hardware) can be expressed in a variety of software languages (e.g., computer code), including Unix utilities, C, C++, Java TM , JavaScript, Ruby, SQL, SAS®, Python, Fortran, R programming language / software environment, Visual Basic TM , and other object-oriented, procedural, or other programming languages and development tools. Examples of computer code include, but are not limited to, microcode or microinstructions, machine instructions, such as produced by a compiler, code used to produce a web service, and files containing higher-level instructions that are executed using an interpreter. Additional examples of computer code include, but are not limited to, control signals, encrypted code, and compressed code. Each device described herein can include one or more processors as described above.

[0302] Some embodiments described herein relate to a device having a non-transitory computer readable medium (also can be referred to as a non-transitory processor readable medium or memory) with instructions or computer code thereon for performing various computer-implemented operations. The computer readable medium (or the processor-readable medium), is a 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 cable). The media and computer code (also can be referred to as code) can 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 drives; optical storage media such as compact disc / digital video disc (CD / DVD), compact disc-read only memory (CD-ROM) and holographic devices; magneto-optical storage media; 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 computer program products, which can include the instructions and / or computer code discussed herein, for example.

[0303] Processor-executable instructions can be in various forms, such as program modules, and can include routines, programs, objects, components, data structures, and other suitable code segments that are designed for execution by one or more computing devices, and can be appropriately combined and / or distributed as desired for various embodiments.

[0304] The phrase “and / or,” as used herein in the specification and in claims, should be understood to mean “either or both of” i.e., “one or both of,” when applied to elements linked by “and / or” to “include” can mean “comprising” (including additional non- specified elements) in one embodiment, and can mean “consisting of’ (including only those elements specified) in another embodiment; or, in another embodiment, can mean “consisting essentially of’ (including additional non-specified elements that do not materially affect the basic performance and operation of the device and method) in another embodiment. The term “method” can refer to techniques described herein, although the scope of methods is not limited to techniques described herein. Furthermore, a particular embodiment of the present disclosure can be implemented as either an apparatus, a method, or a computer program product. The computer program product can include a computer readable medium (or media) having computer readable program instructions thereon for causing a processor to carry out operations described herein and / or one or more components thereof.

Claims

1. A method comprising: receiving, via a processor, a first vector; partitioning, via the processor, the first vector to produce a magnitude vector and a sign vector; generating, via the processor, a second vector comprising a modified magnitude vector and a modified sign vector by: applying a permutation to the magnitude vector to produce the modified magnitude vector, transforming the sign vector to an intermediate sign vector according to an algorithm selected based on a processor-based encryption mode of operation, and applying a plurality of non-linear layers to the intermediate sign vector to produce the modified sign vector, each non-linear layer of the plurality of non-linear layers comprising at least one of a permutation, an S-box transformation, a diffusion linear operation, or an exclusive-OR operation; applying, via the processor, a plurality of linear layers to the second vector to produce a third vector, the third vector being a transformed version of the first vector; and sending a first signal representing the third vector to at least one transmitter to transmit the third vector from the at least one transmitter to at least one receiver.

2. The method of claim 1, wherein transforming the sign vector is based on an initialization vector.

3. The method of claim 1, wherein the algorithm comprises an exclusive-OR operation and the processor-based encryption mode of operation is cipher block chaining (CBC) mode.

4. The method of claim 1, wherein the algorithm comprises an exclusive-OR operation and the processor-based encryption mode of operation is electronic codebook (ECB) mode.

5. The method of claim 1, wherein a number of non-linear layers in the plurality of non-linear layers is equal to a number of linear layers in the plurality of linear layers.

6. The method of claim 1, wherein a number of non-linear layers in the plurality of non-linear layers is different than a number of linear layers in the plurality of linear layers.

7. The method of claim 1, wherein at least one of a number of linear layers in the plurality of linear layers ("L") or a number of non-linear layers in the plurality of non-linear layers ("Q") is equal to [log2(N)].

8. The method of claim 1, wherein at least one of a number of non-linear layers in the plurality of non-linear layers or a number of linear layers in the plurality of linear layers is based on a performance constraint.

9. The method of claim 1, wherein at least one of a number of non-linear layers in the plurality of non-linear layers or a number of linear layers in the plurality of linear layers is based on a security constraint.

10. The method of claim 1, wherein the permutation applied to the magnitude vector does not reduce a total power of the first vector.

11. A method comprising: receiving, via a processor, an input vector comprising a plurality of complex numbers; generating, via the processor, a transformed vector based on the input vector by: applying a permutation to a magnitude vector associated with the input vector to produce a modified magnitude vector, ​ applying a processor-based encryption operation mode selection algorithm and a plurality of nonlinear layers to a sign vector associated with the input vector to produce a modified sign vector, including converting the sign vector to an intermediate sign vector based on the algorithm and applying a plurality of nonlinear layers to the intermediate sign vector to produce the modified sign vector, each nonlinear layer of the plurality of nonlinear layers including at least one of a permutation, an S-box transformation, a diffusion linear operation, or an exclusive OR operation, 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; and sending a first signal representing the transformed vector to at least one transmitter to transmit the transformed vector from the at least one transmitter to at least one receiver.

12. The method of claim 11, wherein each nonlinear layer of the plurality of nonlinear layers includes at least one of a permutation, an S-box transformation, a diffusion linear operation, or an exclusive OR operation.

13. The method of claim 11, wherein the algorithm includes an exclusive OR operation and the processor-based encryption operation mode is one of a cipher block chaining (CBC) mode or an electronic codebook (ECB) mode.

14. The method of claim 11, wherein a number of nonlinear layers of the plurality of nonlinear layers is equal to a number of linear layers of the plurality of linear layers.

15. The method of claim 11, wherein a number of nonlinear layers of the plurality of nonlinear layers is different than a number of linear layers of the plurality of linear layers.

16. The method of claim 11, wherein at least one of a number of linear layers of the plurality of linear layers ("L") or a number of nonlinear layers of the plurality of nonlinear layers ("Q") is equal to [log2(N)].

17. The method of claim 11, wherein at least one of a number of nonlinear layers of the plurality of nonlinear layers or a number of linear layers of the plurality of linear layers is based on at least one of a performance constraint or a security constraint.

18. The method of claim 11, wherein the permutation applied to the magnitude vector does not reduce a total power of the input vector.

Images