arrow-left

All pages
gitbookPowered by GitBook
1 of 1

Loading...

Hard lattice problems

triangle-exclamation

This section is not complete. Help is needed with relevance + examples in cryptography, algorithms + hardness, relations between problems.

Also needs review from more experienced people.

hashtag
Introduction

Now that we are comfortable with lattices we shall study why are they important to cryptography.

Like we said, when we construct cryptosystems we usually are looking for hard problems to base them on. The lattice world provides us with such problems such as the shortest vector problem or the closest vector problem.

What makes lattices even more special is that some cryptographic problems (which we will study in the next chapter) can be reduced to worst-case lattice problems which makes them crazy secure. Moreover, some problems are even secure against quantum computers.

But enough talk, let's get right into it!

hashtag
Shortest vector problem + GapSVP

Before we go into any problems we must first define the concept of distance in a lattice.

Let:

  • Lattice

  • the basis of the lattice

  • the dimension of the lattice

Distance function

Given some distance function (Example: Euclidean norm) the distance from a vector to the lattice is the distance from the vector to the closest point in the in lattice.

We will denote the length of the shortest vector with and the length of the next independent vectors in order with

hashtag
Shortest vector problem

Given a lattice and an arbitrary basis for it our task is to find the shortest vector .

Approximate SVP

We relax the SVP problem a bit. Given an arbitrary basis find a shortest nonzero lattice vector such that . Here is some approximation factor.

hashtag
Decision SVP (GapSVP)

Given a lattice with a basis we must distinguish if or

hashtag
Sage example

hashtag
Closest Vector problem + GapCVP

Closest vector problem

Given a lattice with an arbitrary basis and a vector find the closest lattice vector to

Approximate CVP

Given a lattice with an arbitrary basis and a vector find the closest lattice vector to

hashtag
Decision CVP (GapCVP)

Given a lattice with a basis and a vector we must decide if

  • There exists s.t

hashtag
Sage example

hashtag
Bounded distance decoding

Given a lattice with an arbitrary basis , a vector and a real number find a lattice vector s.t

Remark

  • If we have the solution to the BDD problem is guaranteed to be unique.

hashtag
Shortest independent vectors (SIVP)

Given a full rank lattice with an arbitrary basis find linearly independent lattice vectors of length at most or for the approximate version.

hashtag
Hardness of lattice problems

hashtag
Resources

  • Pictures taken from and "Cryptography made simple - Nigel Smart" and edited a bit

  • Or generated by me

L=L= L=
B=\mathcal B = B=
n=n = n=
ttt
LLL
μ(t,L)=min⁡v∈L∥t−v∥\mu(t, L) = \underset{v \in \mathcal{L}}{\min}{\|t-v\|}μ(t,L)=v∈Lmin​∥t−v∥
∥v∥=λ1(L)\|v\| = \lambda_1(L)∥v∥=λ1​(L)
λi(L)⇒λ1(L)≤λ2(L)≤...≤λn(L)\lambda_i(L) \Rightarrow\lambda_1({L}) \leq \lambda_2({L}) \leq ... \leq \lambda_n({L})λi​(L)⇒λ1​(L)≤λ2​(L)≤...≤λn​(L)
LLL
B\mathcal{B}B
v∈Lv \in Lv∈L
B\mathcal{B}B
v∈Lv \in Lv∈L
v<γ(n)⋅λ1(L)v < \gamma(n)\cdot \lambda_1(L)v<γ(n)⋅λ1​(L)
γ(n)>1\gamma(n) > 1γ(n)>1
LLL
B\mathcal BB
λ1(L)≤1\lambda_1(L) \leq 1λ1​(L)≤1
λ>γ(n)\lambda > \gamma(n)λ>γ(n)
LLL
B\mathcal BB
w∈Rnw \in \mathbb{R}^nw∈Rn
www
v∈L,∥v−w∥≤μv \in {L}, \|v-w\| \leq \muv∈L,∥v−w∥≤μ
LLL
B\mathcal BB
w∈Rnw \in \mathbb{R}^nw∈Rn
www
v∈L,∥v−w∥<γ(n)⋅μv \in {L}, \|v-w\| < \gamma(n) \cdot \muv∈L,∥v−w∥<γ(n)⋅μ
LLL
B\mathcal BB
www
v∈Lv \in Lv∈L
∥v−w∥≤1\| v - w\| \leq 1∥v−w∥≤1
∀v∈L:∥v−w∥>γ(n)\forall v \in L: \|v - w\| > \gamma(n)∀v∈L:∥v−w∥>γ(n)
LLL
BBB
w∈Rnw \in \mathbb{R}^nw∈Rn
d∈Rd \in \mathbb{R}d∈R
v∈Lv \in {L}v∈L
∥w−v∥<d⋅λ1(L)\|w-v\| < d \cdot \lambda_1({L})∥w−v∥<d⋅λ1​(L)
d<12d < \dfrac 12d<21​
LLL
B\mathcal BB
nnn
λn(L)⇒max⁡i∥vi∥≤λn(L)\lambda_n(L) \Rightarrow \max_i\|v_i\| \leq \lambda_n(L)λn​(L)⇒maxi​∥vi​∥≤λn​(L)
max⁡i∣vi∣≤γ(n)λn(L)\max_i|v_i| \leq \gamma(n) \lambda_n(L)maxi​∣vi​∣≤γ(n)λn​(L)
https://simons.berkeley.edu/sites/default/files/docs/14953/intro.pdfarrow-up-right
# We can find the shortest vector using the LLL algorithm
M = matrix([[-1, 2], [-2, 3]])
B = M.LLL()
print(B[0])
# (0, -1)

# Or we can use the Integer Lattice class
L = IntegerLattice(M)
L.shortest_vector()
# (-1, 0)
M = matrix([[-1, 2], [-2, 3]])
L = IntegerLattice(M)

w = vector([1.8, 1.5])
L.closest_vector(w)
# (2.00000000000000, 2.00000000000000)