SLIDE 1
Page: 1
- 12th, May, 2014
1155002056 12th, May, 2014 LI, Xialu - - PDF document
1155002056 12th, May, 2014 LI, Xialu - - PDF document
1155002056 12th, May, 2014 LI, Xialu
SLIDE 2
SLIDE 3
Lattice Reduction for Vector Orthogonalization over Complex Plane and its Relationship to Network Coding
Xuan CAO, Xialu LI under supervision of
- Prof. Shuo-Yen R. LI and Dr. Qifu T. Sun
May 12, 2014
1 Introduction
Physical-Layer Network Coding (PNC) [1] published in 2006 started an almost evolutionary boom in the study of MIMO system in the communication filed. Different from the conventional viewpoint of referring interference as noise, PNC firstly adapted the idea of network coding and interpret the signal interference as a kind of operation on physical layer. This simple but effective idea provided the hope1 to double the transmission rate with following demonstrative scheme. Figure 1: Physical Layer Network Coding Further generalization [2] yielded the famous compute-and-forward model (as demonstrated in 1) as an more precise description of network coding applied on multi-relay (three or more) MIMO communication. Figure 2: Compute and Forward Model with Lattice Decoding
1Two reasons for saying “hope”: 1.
This research was done based on an information theoretical point of view; 2. The transmission scheme followed required multiple assumptions including symmetric condition and transmission simultaneity.
1
SLIDE 4
The information theoretical work was quickly followed by constructive research [3] entitled as “Algebraic Approach”, which applied lattice decoding from early MIMO research [4, 5]. The basic coding-and-decoding scheme, also referred as lattice network coding, is demonstrated below. Figure 3: Lattice Network Coding The coding scheme, originally based on complex lattice over Gaussian Integer (i.e. Z [i]), tries to decode the mixed channel output (y as in above) back to a linear combination of the source messages (i.e. u = N
i=1 aiwi), where the coefficients {ai : i = 1, · · · , N} are chosen from the fine lattice Λ, and the messages
{wi : i = 1, · · · , N} are chosen from the quotient ring Λ/Λ′. The subring Λ′ < Λ can be carefully chosen so that Λ/Λ′ ∼ = Fk
q for some k and q. This made lattice coding a perfect choice for LNC. Moreover, the efficiency
- f such decoding scheme highly depends on the choice of the combination coefficients (a1, a2, · · · , aN). More
precisely, to minimize the error probability is equivalent to find the coefficients a1, a2, · · · , aN to minimize
N
- i=1
aixi where (xi, i = 1, 2, · · · , N) are predetermined by the channel. Above problem is in general referred as “Closet Vector Problem”, and was carefully and systematically studied in 1970s[6]. As a result, LLL Algorithm2 was introduced as an estimate polynomial-time algorithm for lattice reduction. Note that the form N
i=1 aixi is actually an lattice point generated by {x1, x2, · · · , xN}
- ver Z [i]. LLL was originally designed to solve lattice reduction problem in R over Z. However, in current
case{x1, x2, · · · , xN} are always complex. To overcome the problem, a simple adaptation is to change the basis as {ℜ (xi) ⊕ ℑ (xi)} ∪ {ℜ (xi) ⊖ ℑ (xi)}, i.e. for each input matrix X = (x1, x2, · · · , xN)T , generate a new input H =
- ℜ (X)
ℑ (X) −ℑ (X) ℜ (X)
- However, as shown later, this greatly increased the computation amount. Hence, complex LLL was proposed
to solve the problem, which did greatly lower the complexity [7]. The most recent work generalized the lattice network coding to be based on Eisenstein Integer Z [ω] (ω = 1
2 + √ 3 2 i) [8], i.e. the fine lattice Λ and coarse lattice Λ′ are Z [ω]-lattice. There are multiple reasons
for replacing Z [i] by Z [ω]. One of the most appealing one is that F4 is representable under Z [ω], whereas the largest representable even-sized field for Z [i] is only F2. The new work requires the lattice reduction
- ver Eisenstein Integer. Through there exist a generalized LLL which can basically solve lattice reduction
problem over any PID, the LLL over Eisenstein integer has never won a specific research, especially in engineering sense. Moreover, simulations to compare Gaussian integer based and Eisenstein integer based lattice decoding hasn’t be seen in large dimension (i.e. L > 2 in 1), which gives us further motivation to theoretically study and practically implement LLL over Eisenstein integer. In the rest of this report, preliminary knowledge and the original version of LLL algorithm will be shown followed by a detailed study of LLL algorithm over complex case (Z [i] and Z [ω]). Lattice network coding, especially its error performance shall be studied as an application of LLL algorithm afterward. Acknowledgments and references can be found at last.
2Named after mathematician Lenstra, Lenstra and Lovász, for their invention of this algorithm.
2
SLIDE 5
My Contribution to the Work
As an theoretically project, most part of the job were done by the whole group of two people in forms of
- discussion. Besides these major jobs, I focused more on the theoretical proofs of LLL performance bound
and the design of the MATLAB simulation program of LLL time estimation and LNC error simulation.
2 Preliminaries
Notation:
Z the domain of integers Q the field of rational numbers R the field of real numbers C the field of complex numbers Definition 1. A group G, ⋆ is a set G, closed under a binary operation ⋆, such that the following axiom are satisfied: G1: For all a, b, c ∈ G, we have (a ⋆ b) ⋆ c = a ⋆ (b ⋆ c) (associativity of ⋆); G2: There is an element e in G such that for all x ∈ G, e ⋆ x = x ⋆ e = x (existence of identity element under ⋆); G3: Corresponding to each a ∈ G, there is an element a′ ∈ G such that a ⋆ a′ = a′ ⋆ a = e (existence of inverse). Definition 2. A group G is abelian if its binary operation is commutative. Definition 3. A ring < R, +, · > is a set R together with two binary operation + and ·, which we call addition and multiplication, defined on R such that the following three axioms are satisfied: R1: < R, + > is an abelian group. R2: Multiplication is associative. R3: ∀a, b, c ∈ R, the left distributive lawa · (b + c) = (a · b) + (a · c) and right distributive law (a + b) · c = (a · c) + (b · c) hold. Definition 4. We’d like to recall the principle ideal domain based on the concept of ring.
- 1. If a and b are two nonzero elements of a ring R such that ab = 0, then a and b are divisors of 0 (or 0
divisors) (a) An integral domain D is a commutative ring with unity 1 = 0 and containing no divisors of 0. (b) An additive subgroupN of a ring R satisfying aN ⊆ N and Nb ⊆ N is called an ideal of R. (c) If R is a commutative ring with unity and a ∈ R, the ideal aR = {ar|r ∈ R} of all multiples of a is the principal ideal generated by a and is denoted by < a >. An ideal N of R is a principal idea if N =< a > for some a ∈ R. (d) An integral domain D is a principal ideal domain (abbreviated PID) if every ideal in D is a principal ideal. (e) R ⊂ C is a principal ideal domain (PID) if it is a commutative ring such that
- i. For all a, b ∈ R,if ab = 0,then a = 0 or b = 0;
- ii. Every ideal of R can be written as aR = {ar|r ∈ R} for some a ∈ R
Example 1. The ring of integers Z is a principal ideal domain. 3
SLIDE 6
Definition 5. Let R ⊂ Rn (Cn) be a principal ideal domain and N ≤ n be a positive integer. A subset Λ
- f Cn is called an N-dimensional R-lattice if it forms an R-module of rank N.
i.e.
- 1. Λ is closed under addition and under multiplication by scalars in the ring R;
(a) Λ = {N
j=1 rjzj : rj ∈ R (C) ∀j} for some vectors z1, · · · , zN ∈ Λ linearly independent.
Definition 6. In this caseΛ is said to be generated by z1, · · · , zN and {z1, · · · , zN} is a basis of Λ . A subset Λ′ ⊂ Λ is a sublattice of Λ if it is an lattice itself. Note that through out the report, we only consider R to be discrete. More precisely, R could be Z in real case, and Z [i] or Z [ω] in complex case. Definition 7. (Determinant of an lattice and kth Gram determinant) Let 1 ≤ k ≤ N ≤ n, and Λ is a lattice generated by linearly independent row vectors z1, · · · , zN. Write L = [zt
1, zt 2, · · · , zt N]t the determinant of the lattice Λ is defined as
det (Λ) =
- det (LLt).
Remark 1. The determinant of an lattice is independent of the choice of basis. Definition 8. (Gram-Schmidt Orthogonalization (GSO)) Let x1, x2, · · · , xn be a basis of Rn or Cn. The Gram-Schmidt Orthogonalization (GSO) of x1, x2, · · · , xn is the following basis x⋆
1, x⋆ 2, · · · , x⋆ n:
x⋆
1
= x1 x⋆
i
= xi − i−1
j=1 μijx⋆ j
, μij =
xi·x⋆
j
x⋆
j ·x⋆ j
(1 j < i n) . Proposition 1. Let x1, x2, · · · , xn be a basis of Rnor C, and let x⋆
1, x⋆ 2, · · · , x⋆ n be its GSO. Let L be the
lattice generated by x1, x2, · · · , xn. For any nonzero y ∈ L, we have |y| min {|x⋆
i | : i = 1, · · · , n} .
Definition 9. Let x1, x2, · · · , xn be a basis of a lattice Λ, and let X be the n × n matrix with xi in row i for 1 ≤ i ≤ n. For 1 ≤ k ≤ n, let Xk be the k × n matrix consisting of the first k rows of X. The kth Gram matrix of Λ is the k × k symmetric matrix Gk = XkXt
k
The kth Gram determinant of this basis is dk = det(Gk) For convenience we set d0 = 1. Proposition 2. Let x1, x2, · · · , xn be a basis of a lattice Λ, and let x⋆
1, x⋆ 2, · · · , x⋆ n be its GSO. For
1 k n the k−th Gram determinant of the basis is the product of the square-lengths of the GSO vectors: dk = Πk
i=1 |x⋆ i |2 .
Definition 10. (α-Reduced lattice basis) Let l1, l2, · · · , ln be a basis of a lattice Λ, and let x⋆
1, x⋆ 2, · · · , x⋆ n be its GSO. The basis l1, l2, · · · , ln
is called α−reduced (or LLL-reduced with parameter α) if
- 1. |μij| 1
2 for 1 j < i n,
(a)
- x⋆
i + μi,i−1x⋆ i−1
- 2 α
- x⋆
i−1
- 2 for 2 i n.
4
SLIDE 7
Definition 11. Here, μij is the GSO coefficient mentioned in 8, and α ∈ 1
4, 1
- is called the reduction
parameter, and β =
4 4α−1 is called the auxiliary parameter.
Proposition 3. Let x1, x2, · · · , xn be a basis of Rn, and let x⋆
1, x⋆ 2, · · · , x⋆ n be its GSO. Let j be in range
1 j n − 1, and let x1, x2, · · · , xn be the new basis obtained by exchanging xj and xj+1:
- xj = xj+1,
- xj+1 = xj,
- xi = xi
(i = j, j + 1) . Let x⋆
1,
x⋆
2, · · · ,
x⋆
n be the GSO the new basis. Then
x⋆
i = x⋆ i for i = j, j + 1 but
- x⋆
j = x⋆ j+1 + μj+1,jx⋆ j,
- x⋆
j+1 = |x⋆
j+1| 2
|x⋆
j| 2 x⋆
j − μj+1,j |x⋆
j| 2
|x⋆
j| 2 x⋆
j+1 .
3 The Original LLL Algorithm and Closest Vector Problem
The LLL algorithm is a well-known algorithm to find a reduced lattice basis given a basis for high dimensional
- cases. Following is an introduction to this algorithm in an logically incremental style, as an attempt to reveals
the nature of the algorithm. For impatient readers, please jump to the algorithm directly. Note that, in this section, only real lattice will be considered, i.e. the lattice for consideration (i.e. the lattice where a new reduced basis is wanted) is L = K
i=1 rili : ri ∈ Z
- and {l1, l2, · · · , lK} ⊂ Rn are
linearly independent.
3.1 Origin of LLL
The LLL algorithm first rose up in the question of finding integral points in triangles, where the later simple question is believed to underlies many engineering applications. A first intuition would convert this problem into finding a more or most (if can be defined) “regular” basis of the lattice given by the triangle, as illustrated below: The picture on left hand-side is actually isomorphic to the one on the right except the space is distorted with the basis change to a relevant perpendicular and short pair of the lattice (generated by − → OA and − − → OB). The process of finding such basis of an lattice out of an old basis is called the “Lattice Reduction” on the basis. In summary the “Lattice Reduction” means to pursuit a basis {v1, v2, · · · , vK} of the lattice L, s.t.
- 1. |vi| are small for all i;
2.
vi, vj |vi|·|vi| are relatively large for all i = j.
3.2 From Gaussian Algorithm to LLL Algorithm
The simplest version of above problem is for two vectors, in which case, the famous Gaussian algorithm terminates at finding the shortest vector in the lattice over Z generated by the two given vectors. 5
SLIDE 8
Algorithm 1. Gaussian Algorithm Input: A basis {x1, , x2} of a 2-dimensional lattice L over ring R, where ||x1|| ≤ ||x2||. Output: A basis {v1, , v2}of lattice Lwhere v1is the shortest nonzero vector inLand v2is the shortest nonzero vector in L/{βv1 : β ∈R}. Procedure (x1, , x2): Set v1 = x1and v2 = x2, finish_label=0 Algorithm 2. while finish_label = 0 do
- 1. v′
2 = v2−DR(v1vt 2/||v1||2)v1
(a) if ||v′
2|| ≤ ||v1|| thenv2 := v1 and v1 := v′ 2 else v2 := v′ 2and finish_label=1.
end while Algorithm 3. whereDR(x) = y if y ∈ R such that y minimizes ||x − y||. If we extend the algorithm for the simple two independent vectors case to three independent vectors case, it is very natural to apply Gaussian algorithm to the the first two vectors and get two new vectors. Suppose the three vectors are x1, , x2, x3and after applying Gaussian algorithm to x1, , x2, we get v1, , v2, , x3. We reduce the length of x3projected on Span{x1, , x2}by a similar step of step 1 in Gaussian algorithm, and then decide whether to exchange the updated x3and v2 by some criteria. If there is an exchange of x3and v2, then reduce the length of x3projected onv1 and then compare x3andv1to decide whether to exchange them again. In this way, we get a set of reduced lattice basis of three vectors. The original LLL algorithm for lattice in Rnover Z is using a similar idea. Algorithm 4. LLL Algorithm Input: A basis x1, x2, · · · , xn of the lattice L ⊂ Rn over Z, and a reduction parameter α ∈ 1
4, 1
- .
Output: An α−reduced basis y1, y2, · · · , yn of lattice L. Variables with meaning: (We’ll keep updating to ensure the correspondence of below “meanings”s)
- Y = [y1, y2, · · · , yn]t is the matrix containing all working vectors (as rows).
Note that initially Y = X = [x1, x2, · · · , xn]t. – Y ⋆ = [y⋆
1, y⋆ 2, · · · , y⋆ n]t is the matrix containing the GSO result of Y , i.e. y⋆ i = yi − i−1 j=1 μijy⋆ j
where μij =
yi·y⋆
j
|y⋆
j| 2 .
– M = [μij] is an n × n matrix where μii = 1 for all i and μij = 0 for all j > i. Then Y ⋆ = M · Y – γ⋆
i = |y⋆ i |2 for all i
Algorithm 5. Procedure reduce (k, l): (l < k) If |μkl| > 1
2 theny1, y2, · · · , yn
- 1. K = DZ(μkl) ;
(a) yk ← yk − K · yl; (b) Subtract K times of row l from row k in matrix M = (μij) Algorithm 6. Procedure exchange (k): (k > 1)
- 1. Exchange the values of yk−1 and yk;
(a) By 3, we have y⋆
k ← y⋆ k, y⋆ k−1 ← y⋆ k−1 and
y⋆
k−1 ← y⋆ k + μk,k−1y⋆ k−1
y⋆
k ←
μk,k−1 · γ⋆
k−1
γ⋆
k + (μk,k−1)2 · γ⋆ k−1
· y⋆
k +
γ⋆
k
γ⋆
k + (μk,k−1)2 · γ⋆ k−1
y⋆
k−1
6
SLIDE 9
(b) Update M as: (Note that all variables on the RHS are old values, they are first stored then used for calculation)
- i. Exchange row k-1 and k;
- ii. μk−1,k−1 ← 1, μk−1,k ← 0;
- iii. μk,k−1 ←
μk,k−1·γ⋆
k−1
γ⋆
k+(μk,k−1)2·γ⋆ k−1 , μk,k ← 1;
- iv. For each i > k, μi,k−1 ← μi,k + μi,k−1 · μk,k−1;
μi,k ←
μk,k−1·γ⋆
k−1
γ⋆
k+(μk,k−1)2·γ⋆ k−1 · μi,k +
γ⋆
k
γ⋆
k+(μk,k−1)2·γ⋆ k−1 · μi,k−1;
(c) Update γ⋆ as: (Note that all variables on the RHS are old values, they are first stored then used for calculation)
- i. γ⋆
k ←
- μk,k−1·γ⋆
k−1
γ⋆
k+(μk,k−1)2·γ⋆ k−1
2 γ⋆
k +
- γ⋆
k
γ⋆
k+(μk,k−1)2·γ⋆ k−1
2 γ⋆
k−1;
- ii. γ⋆
k−1 ← γ⋆ k + μ2 k,k−1γ⋆ k−1.
Algorithm 7. Main Procedure:
- 1. Copy yi ← xi for all i ∈ {1, 2, · · · , n};
(a) GSO: Y ⋆ = MY ; (b) Set k ← 2 (c) While k n do:
- i. reduce (k, k − 1);
- ii. If γ⋆
k
- α − μ2
k,k−1
- γ⋆
k−1 then
- A. For l = k − 2, · · · , 2, 1 do: reduce (k, l);
- B. Set k ← k + 1;
else
- C. exchange (k);
- D. If k > 2 then set k ← k − 1.
For 2 ≤ k ≤ n, at the kth stage of the main procedure, we assume that we have obtained an α−reduced basis of the first k-1 vectors. Consider the first k-1updated vectors in reduced form with the kth vector xk. First reduce the length of the vector yk = xkprojected on Span{y1, , y2, · · · , yk−1} by reduce(k, k − 1). Then decide whether to exchange yk−1 and yk by the criteria of step 4b in the main procedure, i.e. checking condition γ⋆
k
- α − μ2
k,k−1
- γ⋆
k−1 . If we do need to change, then we will exchange the two vectors and do
the previous reduce procedure and exchange procedure on the set {y1, , y2, · · · , yk−1} . We keep reducing the length of the the kth vector xk of the input and comparing it with the vector ahead of it until no exchange
- peration is needed. After all these updates, the set {y1, , y2, · · · , yk} is a α−reduced basis set.
We extend the α−reduced basis set by adding one vector each time. Finally, that set will be extended to be an α−reduced basis y1, y2, · · · , yn of lattice L. Theorem 1. LLL Theorem If x1, x2, · · · , xn is an α−reduced basis of the lattice L in Rn, and y ∈ L is any nonzero lattice vector, then |x1| ≤ β(n−1)/2|y| where β =
4 4α−1
In particular, the first vector in the α−reduced basis is no longer than β(n−1)/2 times the shortest nonzero vector in L.
- Remark. This theorem gives a upper bound of the first vector in the α−reduced basis.
7
SLIDE 10
Closest Vector Problem (CVP) is an optimization problem on lattices. As its name suggests, it is a problem of finding the vector in a lattice closest to a certain vector v given a basis for the lattice and a norm
- N. CVP is associated with Lattice Network Codes (LNC) since to reduce the error probability we need to
find the shortest vector in a lattice i.e. the vector closest to zero vector in a lattice. LLL algorithm helps to approximately find the shortest vector in the lattice and the first vector in the α−reduced basis is guarantee to be not far from the real shortest vector in the lattice.
- Example. α is usually taken to be 3
- 4. In this case, β = 2. For n = 7, |x1| ≤ 23|y| = 8|y|.
Theorem 2. (Termination Theorem) The total number of passes through the loop in Step (4) of the main procedure is at most −2 log B log α n (n − 1) + (n − 1) Remark 2. For fixed α, the number of loops performed by the LLL algorithm is O
- n2 log B
- , the number
- f arithmetic operations performed is O
- n4 log B
- . The LLL algorithm is a polynomial-time algorithm.
4 Extension to Complex LLL Algorithm
Using exactly same concept, and same intuition, the LLL algorithm introduced in last section can be gen- eralized to complex case, where the processed vectors are in C, and the underlying PID is chosen to be either Z [i] or Z [ω]. i.e. considering lattice Λ = K
i=1 rili
- where ri ∈ Z [i] = {a + bi : a, b ∈ Z} or
ri ∈ Z [ω] = {a + bω : a, b ∈ Z}, and {l1, l2, · · · , lK} ⊂ Cn linearly independent. (Note that ω = 1
2 + √ 3 2 i.)
4.1 Complex Version of LLL Algorithm
Keeping the note that the concept and even the notations of the algorithm can be easily extended to complex case, the main frame of the algorithm can be kept, and as a result following is an “nature” update: Algorithm 8. (Recall) Main Frame of LLL Algorithm
- 1. Copy yi ← xi for all i ∈ {1, 2, · · · , n};
(a) GSO: Y ⋆ = MY ; (b) Set k ← 2 (c) While k n do:
- i. reduce (k, k − 1);
- ii. If γ⋆
k
- α − μ2
k,k−1
- γ⋆
k−1 then
- A. For l = k − 2, · · · , 2, 1 do: reduce (k, l);
- B. Set k ← k + 1;
else
- C. exchange (k);
- D. If k > 2 then set k ← k − 1.
To verify and update above algorithm for complex version, three things need to be checked and update:
- 1. The sub-routing exchange;
- 2. The sub-routing reduce;
- 3. The validity of α − μ2
k,k−1 > 0 after reduce (k, k − 1).
8
SLIDE 11
4.1.1 Complex sub-routing exchange(k) The functionality of this procedure is to exchange the order of the basis by switching ykand yk−1, briefly as below:
- 1. Switching ykand yk−1;
- 2. Update the GSO coefficient table (μij).
The detailed processing is just the result of 3, i.e. after switching y⋆
i = y⋆ i for i = j, j + 1 but
- y⋆
j = y⋆ j+1 + μj+1,jy⋆ j,
- y⋆
j+1 = |y⋆
j+1| 2
|y⋆
j| 2 y⋆
j − μj+1,j |y⋆
j| 2
|y⋆
j| 2 y⋆
j+1 .
Luckily, above result could easily be verified on complex environment, which means that the exchange sub-routing need not to be updated for complex environment. However, since it’s trivial and tedious, please refer appendix for detailed verification. 4.1.2 Complex sub-routing reduce(k, l) The functionality of this procedure is to cancel out integral multiple of yl out of yk such that the component
- f yk alongside y⋆
l can be minimized. The process is briefly as below: (below is an general version)
- Algorithm. (General version of basis reduction) If μkl is out of range, i.e. the component of yk alongside
y⋆
l can be minimized then
- 1. K = nearest integer to μkl (|μkl| 1);
(a) yk ← yk − K · yl; (b) Subtract K times of row l from row k in matrix M = (μij) (we actually do this by changing μks ← μks − μls for all s). However, we do have different concept on “nearest integer” for Z, Z [i] , Z [ω]: Nearest Integer Example Picture illustration Z a → ⌊a⌉ 5.6 → 6 Z [i] a + bi → ⌊a⌉ + ⌊b⌉ i 5.4 + 0.7i → 5 + i Z [ω] a + bi →
- a − 1
2
- 2
√ 3b 3
- +
- 2
√ 3b 3
- i
5.4 + 0.7i → 6 + ω Thus, we’ll need to change the sub-routing reduce(k, l)to fit the scenario, detailed as below:
- Algorithm. (Reduce for Gaussian Integer Case)
If |ℜ (μkl)| > 1
2 or |ℑ (μkl)| > 1 2
- 1. K = ⌊ℜ (μkl)⌉ + ⌊ℑ (μkl)⌉ i;
(a) yk ← yk − K · yl; (b) Subtract K times of row l from row k in matrix M = (μij) (we actually do this by changing μks ← μks − μls for all s).
- Algorithm. (Reduce for Eisenstein Integer Case)
If 1
2 · |ℜ (μkl)| + √ 3 2 |ℑ (μkl)| > 1 2 or |ℜ (μkl)| > 1 2
(a) K =
- ℜ (μkl) − 1
2
- 2
√ 3ℑ(μkl) 3
- +
- 2
√ 3ℑ(μkl) 3
- i;
- i. yk ← yk − K · yl;
- ii. Subtract K times of row l from row k in matrix M = (μij) (we actually do this by changing
μks ← μks − μls for all s). 9
SLIDE 12
4.2 Range of GSO coefficient after reduction
I’s easy to see that the range of GSO coefficient (i.e. μkl) after we call the procedure reduce(k, l) under different cases: Case Range Norm range Z
- − 1
2, 1 2
- 0, 1
2
- Z [i]
- − 1
2, 1 2
- ×
- − 1
2, 1 2
- i
- 0,
√ 2 2
- Z [ω]
1 2 · |ℜ (μkl)| + √ 3 2 |ℑ (μkl)| 1 2 or |ℜ (μkl)| 1 2
- 0,
√ 3 3
- This means that, we can only guarantee μ2
k,k−1 1 2 for Gaussian Integer LLL Algorithm. Hence, we
have Case Range of LLL Reduction Parameter α Z 1
4, 1
- Z [i]
1
2, 1
- Z [ω]
1
3, 1
- 5
Performance Analysis: Speed and Accuracy
5.1 Derivation of Performance of General LLL in theory
Theorem 3. (Generalized LLL Theorem) If x1, x2, · · · , xn is an α−reduced basis of the lattice L, and y ∈ L is any nonzero lattice vector, then |x1| β(n−1)/2 |y| . Where β = 4 4α − 1 in case of Real LLL β = 3 3α − 1 in case of Z [ω]-LLL β = 2 2α − 1 in case of Z [i]-LLL In particular, the first vector in the α−reduced basis is no longer than β(n−1)/2 times the shortest nonzero vector in L.
- Proof. By 10, we have
|x⋆
i |2
- α − μ2
i,i−1
x⋆
i−1
- 2
According to section 4.2, we have Above ⎧ ⎪ ⎨ ⎪ ⎩
- α − 1
4
x⋆
i−1
- 2
in case of Real LLL
- α − 1
3
x⋆
i−1
- 2
in case of Z [ω]-LLL
- α − 1
2
x⋆
i−1
- 2
in case of Z [i]-LLL Let β = ⎧ ⎪ ⎨ ⎪ ⎩
4 4α−1
in case of Real LLL
3 3α−1
in case of Z [ω]-LLL
2 2α−1
in case of Z [i]-LLL we have |x⋆
i |2 1
β
- x⋆
i−1
- 2
Since x⋆
1 = x1, we have
|x1|2 = |x⋆
1|2 β |x⋆ 2|2 β2 |x⋆ 3|2 βn−1 |x⋆ n|2
10
SLIDE 13
Hence for 1 i n, we have |x⋆
i |2 β−(i−1) |x1|2
By 1, we have for any y ∈ L, we have |y| min {|x⋆
i | : i = 1, · · · , n} β(n−1)/2 |x1|
Lemma 1. During the calls to reduce (k, l) in the LLL algorithm, the Gram determinants di do not change. During the calls to exchange (k), the Gram determinants di do not change for i = k − 1, but dk−1 change to a new value d′
k−1 αdk−1, where α is the reduction parameter.
- Proof. By 2
di = Πi
j=1
- y⋆
j
- 2
since y⋆
j remains untouched in procedure reduce for all j, we are sure the Gram determinants do not change
in this case. Note that exchange (k) only reordered y1, y2, · · · , yn by exchanging the k−th and (k − 1) −th elements. Hence, Gl for l < k − 1 remains untouched, and Gl for l > k − 1 experienced an exchange of row and an exchange of column. Therefore, dl = det (Gl) remains unchanged for l = k − 1. Now let y⋆
l and z⋆ l denote the orthogonal basis before and after exchange (k), where l = 1, 2, · · · , n.
d′
k−1
= Πk−1
j=1
- z⋆
j
- 2
=
- z⋆
k−1
- 2 · Πk−2
j=1
- z⋆
j
- 2
Since, z⋆
k−1 = y⋆ k + μk,k−1y⋆ k−1 and γ⋆ k <
- α − μ2
k,k−1
- γ⋆
k−1, we have
- z⋆
k−1
- 2
= γ⋆
k + μ2 k,k−1 · γ⋆ k−1
<
- α − μ2
k,k−1
- γ⋆
k−1 + μ2 k,k−1 · γ⋆ k−1
= αγ⋆
k−1
= α
- y⋆
k−1
- 2
Hence, d′
k−1
=
- z⋆
k−1
- 2 · Πk−2
j=1
- z⋆
j
- 2
< α
- y⋆
k−1
- 2 · Πk−2
j=1
- z⋆
j
- 2
= α
- y⋆
k−1
- 2 · Πk−2
j=1
- y⋆
j
- 2
= α · Πk−1
j=1
- y⋆
j
- 2
= α · dk−1 This finished proof. Lemma 2. Let E denote the total number of calls to exchange performed through the LLL algorithm, then E −log B log α n (n − 1) ans thus the algorithm does terminate, and therefore is correct.
- Proof. Define D = Πn−1
k=1dk to be the multiplication of all Gram determinant. In particular, denote D0 for
the value of D at the beginning of the algorithm. Then
- Claim. D0 Bn(n−1) where B = max (|x1| , |x2| , · · · , |xn|)
11
SLIDE 14
Case Time Accuracy Z-LLL − 2 log B
log α n (n − 1) + (n − 1)
|x1| β(n−1)/2 |y| where β =
4 4α−1
Z [i]-LLL |x1| β(n−1)/2 |y|where β =
2 2α−1
Z [ω]-LLL |x1| β(n−1)/2 |y|where β =
3 3α−1
Table 1: Speed and Accuracy of different LLL in theory
- Proof. By 2:
D0 = Πn−1
k=1dk
= Πn−1
k=1Πk l=1 |x⋆ l |2
=
- |x⋆
1|2
|x⋆
1|2 |x⋆ 2|2
· · ·
- |x⋆
1|2 |x⋆ 2|2 · · ·
- x⋆
n−1
- 2
- B2
B2B2 · · ·
- B2B2 · · · B2
= Bn(n−1) Note that by lemma 1, each call to exchange will decrease D to or lower than αD. However, D is always a positive integer. Hence, 1 αED0 ∴ α−E D0 Bn(n−1) ∴ −E log α n (n − 1) log B ∴ E − log B
log α n (n − 1) since 0 < α < 1 ⇒ − log α > 0
Theorem 4. (Termination Theorem for Complex Version LLL) The total number of passes through the loop in Step (4) of the main procedure is at most −2 log B log α n (n − 1) + (n − 1)
- Proof. Denote the total number of passes through the loop by N.
Still, let E denote the total number of calls to exchange performed through the LLL algorithm. Also, let E′ denote the number of (b) (i) (ii) in 8 (i.e. the opposite branch flow) performed. Then, N = E + E′ Note that for each one in E, k will decrease by 1 and for each one in E′ k will increase by 1. Hence, klast − kinitial = n + 1 − 2 = n − 1 = E′ − E ∴ E′ = E + (n − 1) ∴ N = E + E′ = 2E + (n − 1) = − 2 log B
log α n (n − 1) + (n − 1)
As a summary, we have following table
5.2 Theoretical Comparison: Same Accuracy, compare time
For Z [i]-LLL (Gaussian) to have same accuracy with Z [ω]-LLL (Eisenstein) in theory, we need
3 3αE−1 = 2 2αG−1. Here we use αG and αH to denote the LLL-reduced parameter for Gaussian and Eisenstein case
- respectively. Then, we have αG = αE + 1
- 6. Note that αG ∈
1
2, 1
- , αH ∈
1
3, 1
- , we’ll have a cross region as
αG ∈ 1
2, 1
- , αH ∈
1
3, 5 6
- .
Hence, Time for Z [ω] -LLL Time for Z [i] -LLL = − 2 log B
log αE
− 2 log B
log αG
= log αG log αE = log
- αE + 1
6
- log αE
and it is plotted as follows: 12
SLIDE 15
Figure 4: Theoretical Comparison Between Z [ω]-LLL and Z [i]-LLL: Same Accuracy, compare time
5.3 Theoretical Comparison: Same time, compare Accuracy
For Z [i]-LLL (Gaussian) to have same speed with Z [ω]-LLL (Eisenstein) in theory, we need αG = αH, where αG and αH are defined as before, in last subsection. Then, we have Accuracy for Z [ω] -LLL Accuracy for Z [i] -LLL =
- 3
3α−1
(n−1)/2
- 4
4α−1
(n−1)/2 = 12α − 3 12α − 4 (n−1)/2 and it is plotted as follows: Figure 5: Theoretical Comparison: Same time, compare Accuracy with n = 3 13
SLIDE 16
Figure 6: Theoretical Comparison: Same time, compare Accuracy with n = 10
5.4 Simulation Comparison
Through the theoretical result seems to be inspiring, the simulation result suggest that LLL on Gaussian Integer and on Eisenstein Integer have similar complexity. However, the original LLL cannot process complex
- vectors. One way is input a double sized matrix H (for each complex matrix input X) defined as follows
H =
- ℜ (X)
ℑ (X) −ℑ (X) ℜ (X)
- A simulation result with α = 0.75, matrix dimension N floating from 2 to 20 yield following results
Figure 7: Time Consumption Simulation with fixed α = 0.75 and different dimension N 14
SLIDE 17
Figure 8: Time Consumption Simulation with fixed N = 10 and different α
6 Application on Lattice Network Coding and the Simulation Re- sult
6.1 The compute-and-forward model
Figure 9: The compute-and-forward model The more detailed compute-and-forward model mentioned in the introduction section is redrawn as above. In the compute-and-forward scheme, there are N independent transmitters and each of them sends one message via a Gaussian multi-access channel (MAC). Message Space Given PID, say R (can be any one of Z, Z [i] , Z [ω]), of above lattice network coding scheme, the massage space is defined as W = Λ/Λ′, where Λ is a lattice over R, and Λ′ < Λ is a chosen sublattice such that Λ/Λ′ is finite. Encoder Before transmission, each message wi ∈ W = Λ/Λ′ is encoded as its smallest coset leader, i.e. E : W = Λ/Λ′ → Λ ⊂ Cn such that 15
SLIDE 18
- 1. E (w1) = E (w2) for each w1, w2 in same coset, i.e. w2 − w1 ∈ Λ′;
- 2. For each w ∈ Λ, E (w) E (w′) for any w′ ∈ w + Λ′.
Channel The received signal at the relay is y = N
i=1 hixi + z where hi is the i-th fading coefficient and xi = E (wi),
and z represents a complex circularly-symmetric additive white Gaussian noise (AWGN) vector. Decoder Given a coefficient vector a = (a1, · · · , aN) over R and a scaling factor α ∈ C, the relay receiver tries to decode yinto an R-linear combination of the transmitted message u = N
i=1 aiwi, by mapping y to the
nearest lattice point of αy, i.e. D (y) = QΛ (αy) where QΛ is the lattice quantization function. In case Λ = Z, Z [i] or Z [ω], QΛ was demonstrated in section 4.1.2.
6.2 Decoding and the relation of LNC and LLL algorithm
For the LNC described above, given a, we can find best α [2] as α = a · hHSNR SNR||hH|| + 1. The union bound estimation of decoding error rate is given as Perror K(Λ/Λ′)exp(− d2(Λ/Λ′) 4N0aMaH ) where M = SNRIN −
SNR2 SNR||h||2+1hhH.
Let L be the lower triangular matrix such that M = LLH since M is Hermitian and positive-definite. The decoding error rate can be rewritten as Perror ≈ K(Λ/Λ′)exp(− d2(Λ/Λ′)
4N0|aL|2 ). To minimize the error rate,
the best choice of a is a = argmina∈RN |aL|2. Since {aL : a ∈ R} is exactly the lattice generated by the rows of L, to find the best choice of a is equivalent to find the shortest vector in this lattice. Forn = 2, Gaussian algorithm can be applied to find the shortest vector. For n ≥ 3, LLL algorithm can be used to find an reduced basis, and the first vector of the reduced basis can be viewed as an estimate shortest vector.
6.3 Migration from Original LLL (RLLL) to the complex version (CLLL)
Since the vectors in the basis of the lattice, in which we try to find the shortest vector, is complex-valued, traditionally, LLL reduction is performed on L = [ ℜ(L) ℑ(L) −ℑ(L) ℜ(L) ]. This will cause a doubling in dimension and hence generally requires extra computations. CLLL algorithm directly works on complex lattice. Although each complex arithmetic operation costs more, the totally number of operation has reduced a lot. Hence CLLL algorithm has a lower overall complexity than applying real LLL (RLLL) algorithm in this case. This has been demonstrated in 5.4. 16
SLIDE 19
6.4 Simulation and Comparison of LNC over Z [i] and Z [ω]
One advantage of Z[ω] is that a field of character 4 F4 can be represented by the lattice partition Z[ω]/2Z[ω] while for Z[i] the only field can be represented by lattice partition Z[i]/βZ[i] is F2which is a field of character
- 2. This means that the message space W is larger when using Lattice Network Code based (LNC) based on
Z[ω] than Z[i]. Moreover, as pointed by Sun [8], the LNC over Z [ω] yields extra shaping gain and more coding gain, as a result of which, one can expected better performance (in terms of error) of Z [ω]-LNC. Indeed, following proposition gives the the average power for the constellation of Λ/γΛ where Λ = Z [i] or Z [ω]. Proposition 4. Given Λ1 = Z [i], Λ2 = Z [ω] are two trivial lattices over PID Z [i] and Z [ω] respectively. Suppose γ1 ∈ Z [i], γ2 ∈ Z [ω] and |γ1| = |γ2| = |γ|, then Λ′
1 = γ1Λ1 < Λ1, Λ′ 2 = γ2Λ2 < Λ2 and the average
power for the constellation of Λ1/Λ′
1 and Λ2/Λ′ 2 are given as
E [E (w) : w ∈ Λ1/Λ′
1] ≈ |γ|2
6 E [E (w) : w ∈ Λ2/Λ′
2] ≈ 5 · |γ|2
36
- Proof. Via continuous approximation,
E [E (w) : w ∈ Λ/Λ′] ≈ ˆ
V (Λ/Λ′)
- z2
- |V (Λ/Λ′)|dA
where V (Λ/Λ′) {z ∈ C : |z + v| |z| ∀v ∈ Λ′} . In this case, E [E (w) : w ∈ Λ1/Λ′
1] ≈
ˆ
γ 2
− γ
2
ˆ
γ 2
− γ
2
x2 + y2dxdy E [E (w) : w ∈ Λ2/Λ′
2] ≈ 6 ·
ˆ
γ 2
ˆ
√ 3 6 x
−
√ 3 6 x
x2 + y2dydx By estimating above, one shall get the result.
Simulation Result
Note that Z [i] / (2 + 3i) Z [i] ≃ F13 ≃ Z [ω] / (4 + 3ω) Z [ω] Following is the simulated result of symbol error rate of the 3-User LNCs over Z [i] and Z [ω] with respect to different SNR (Signal-to-Noise Ratio): 17
SLIDE 20
Figure 10: Simulated Error Rate of LNC generated by Z [i] / (2 + 3i) Z [i] and Z [ω] / (4 + 3ω) Z [ω] with respect to SNR
7 Future Work
There are still multiple possible related work in the future, listed as follows. Lattice Network Codes based on Integers, Gaussian integers and Eisenstein integers are compared in our
- work. For cases of dimension larger than two, based on our theoretical analysis and practical simulation
results Lattice Network Codes over Eisenstein Integers can perform better than Gaussian integers under comparable conditions. It remains to be explored whether there existent other principal ideal domain (PID)
- ver which the Lattice Network Codes work better.
As observed from simulations, the channel coefficients which depict the channel property h = (h1, h2, · · · , hN) is having a noticeable influence over the transmission error probability with or without optimized parameters. Further study of the relation between these coefficients and transmission performance are needed whenever such patterns over channel coefficients improving or debasing the performance. LLL algorithm has always been the key to the realization of multi-user LNC. However, since the bound
- f the accuracy of complex LLL algorithm is quite loose for significant high dimension cases, there is no
guarantee that the performance of complex LLL algorithm is still acceptable for those cases. Therefore, it is still a long-term job to study possible better algorithm for lattice reduction problem.
8 Acknowledgment
We’d like to thank Prof. Robert LI for his kind supervision, and great patience in helping us in many aspects. We would also like to appreciate Dr. Tyler Sun who helped us understand the engineering application of the LLL algorithm, and gave us a great motivation to solve the problem. In addition, we’d like to thank each other for the tacit cooperation and understanding.
References
[1] Shengli Zhang, Soung Chang Liew, Patrick P. Lam, “Hot Topic: Physical-Layer Network Coding”, 2006 18
SLIDE 21
[2] B. Nazer and M. Gastpar, “Compute-and-Forward: Harnessing Interference through Structured Codes,” submitted to IEEE Transactions On Information Theory, August 2009. [3] C. Feng, D. Silva, and F. R. Kschischang, “An algebraic approach to physical-layer network coding,” submitted to IEEE Trans. Inf. Theory (see arXiv:1108.1595v1). [4] Wai Ho Mow, “Universal lattice decoding: a review and some recent results”, 2004 IEEE International Conference on Communications. Vol. 5, pp. 2842-2846, 2004. [5] Wai Ho Mow, “Maximum Likelihood Sequence Estimation from the Lattice Viewpoint”, IEEE Transac- tions on Information Theory, September, 1994 [6] Murray R. Bremner, “Lattice Basis Reduction: An Introduction to the LLL Algorithm and Its Applica- tions”, 2012 [7] Ying Hung Gan, Cong Ling, Member, and Wai Ho Mow, “Complex Lattice Reduction Algorithm for Low-Complexity Full-Diversity MIMO Detection”, IEEE Transactions on Signal Processing, July 2009 [8] Qifu Tyler Sun, Jinhong Yuan, Tao Huang, and Kenneth W. Shum, “Lattice Network Codes Based on Eisenstein Integers”, IEEE Transactions on Communications, Vol. 61, No. 7, July 2013 19