[Paper Review] Incremental Algorithms for Lattice Problems

Boris Hemkemeier, Frank Vallentin|ArXiv.org|Apr 13, 2006

Cryptography and Data Security4 references3 citations

TL;DR

This paper presents incremental algorithms for fundamental lattice problems—basis computation, successive minima determination, and orthogonal decomposition—by processing lattice generators one at a time. It proves an upper bound of $ d + \log_2(d!(B/\lambda_1(L))^d) $ on the number of update steps, enabling efficient computation by minimizing expensive basis recalculations.

ABSTRACT

In this short note we give incremental algorithms for the following lattice problems: finding a basis of a lattice, computing the successive minima, and determining the orthogonal decomposition. We prove an upper bound for the number of update steps for every insertion order. For the determination of the orthogonal decomposition we efficiently implement an argument due to Kneser.

Motivation & Objective

• To design incremental algorithms that compute lattice properties by processing generators sequentially, minimizing costly basis recomputations.
• To establish a theoretical upper bound on the number of update steps required during incremental lattice construction.
• To provide an efficient implementation of Kneser's constructive proof for orthogonal decomposition of lattices.
• To leverage the concept of length-decomposable vectors to reduce computational overhead in detecting orthogonal components.
• To offer a practical meta-algorithm with performance advantages over standard lattice algorithms, especially when update steps are sparse.

Proposed method

• Use an incremental framework where each new vector is first localized (checked for membership in the current lattice span), then updated only if it increases the lattice rank.
• Apply Minkowski's theorem to bound the product of successive minima and relate it to the volume ratio, enabling step count estimation.
• Transform the incremental chain of sublattices into a full-rank chain to analyze index growth via volume ratios.
• Utilize graph-theoretic methods on a graph of orthogonal non-orthogonality relations among short lattice vectors to detect connected components corresponding to indecomposable sublattices.
• Define length-decomposable vectors as those expressible as a sum of two non-zero lattice vectors with norms at most that of the original vector, enabling efficient detection of indecomposable components.
• Maintain a dynamic set of orthogonal, indecomposable sublattices and merge them with new vectors only when they project non-trivially onto existing components, ensuring orthogonality and indecomposability.

Experimental results

Research questions

• RQ1 What is the maximum number of update steps required when incrementally constructing a lattice from a given set of generators?
• RQ2 How can the orthogonal decomposition of a lattice be computed efficiently using incremental processing?
• RQ3 Can the concept of length-decomposable vectors be used to simplify the detection of indecomposable sublattices?
• RQ4 What is the computational complexity of computing successive minima incrementally using a complete generating set?
• RQ5 How does the incremental framework reduce computational cost compared to batch processing of lattice problems?

Key findings

• The number of update steps in the incremental lattice construction is bounded by $ d + \log_2(d!(B/\lambda_1(L))^d) $, where $ d $ is the lattice rank and $ B $ is the maximum norm of the generators.
• The algorithm for successive minima computes $ \lambda_1(L), \ldots, \lambda_d(L) $ by processing vectors in increasing norm order and updating the lattice basis only when necessary.
• The orthogonal decomposition algorithm efficiently identifies indecomposable sublattices by constructing a graph on length-decomposable vectors and computing connected components in linear time relative to the number of vectors.
• The proposed method for orthogonal decomposition ensures that all resulting sublattices are pairwise orthogonal and indecomposable, with correctness proven via induction on the incremental process.
• The algorithm for orthogonal decomposition runs in time linear in the number of vectors in the complete generating set, due to the use of length-decomposable vectors and efficient component detection.
• The framework provides a significant performance improvement over standard implementations by minimizing expensive basis computations, particularly when the number of update steps is small.