Felix' Math Place » finite abelian group

Finding Lattice Points, Finite Abelian Groups, and Explaining Algorithms.

Felix Fontein — Fri, 29 Jan 2010 10:20:34 +0000

In this article, I want to discuss three questions, which turn out to be closely related. The first question is,

“Given a lattice . How do I find a basis of this lattice?”

(Note that this question is far from being well-posed.) The second question is,

“If is a finite abelian group and , how do I compute the structure of , the subgroup generated by these elements?”

The third question comes up in the description of algorithms, for example of the baby-step giant-step algorithm by D. Shanks, an optimization by D. Terr, and more general algorithms, like the Buchmann-Schmidt algorithm. These algorithms can be described in terms of the first question, making them easier to understand.

We begin with sketching the relation between lattices and finite abelian groups. If is a finite abelian group, and some elements, for example, a set of generators, consider the map This turns out to be a group homomorphism onto . The kernel of , which we will denote by , is called the relation lattice. This is in fact a lattice in of volume note that by the Homomorphism Theorem, . On the other hand, if is a lattice, then is a finite abelian group of elements. Moreover, if the residue class of , the vector consisting of zeroes except a one at the -th position, in is denoted by , then . Therefore, lattices in and finite abelian groups with generators are essentially the same thing.

How is this related to group structure computations? Recall the Smith normal form; this allows to convert a basis of a lattice into another basis, such that if one applies an invertible linear transformation to , this basis is sent to with 0}' title='\lambda_i \in \N_{>0}' class='latex-inline' /> such that divides , ; then, . Hence, computing the structure of a finite abelian group generated by can be split up in the two parts, (a) computation of a basis of the relation lattice and (b) computation of a Smith normal form of this basis. There exist a lot of algorithms for computation of Smith normal forms; usually, the bottleneck is finding a basis of .

Often, the process of finding a lattice equals determining the relation lattice of a finite abelian group, or something similar. One often has a way to test whether , by computing a unique representation of the residue class ; then, one tries to find two ways of writing the same residue class, but with : then is a non-trivial element of . If one sets , then this means that one seeks for pairs , , where and , such that and .

More generally, assume that is a finite set and is a map such that for all . Our above example, and satisfies this. Moreover, assume that is “mostly injective”, i.e. that implies that one can find such that , , with very little effort. Then one can work with elements with , and try to find two such pairs , with ; then this gives rise to an element of near to .

Which brings us to the subject of explaining algorithms. Consider, for example, Shanks’ baby-step giant-step algorithm. You are given a group element of finite order together with a bound 0' title='B > 0' class='latex-inline' />. Then, for the algorithm, one computes , as well as , and compares this elements with the first elements. Any match will result in a multiple of the order of . But why is this the case? One can of course try to prove this; it is actually not very hard, in fact one just needs Fermat’s Little Theorem as well as long division. But one can do better, by visualizing the algorithm in a way which makes the solution looking obvious, and which allows even people who have no understanding of formal mathematics or computer science to immediately realize that the algorithm produces the correct result.

Namely, you might have guessed it, the order of generates the relation lattice . Hence finding the order is equivalent to finding a the smallest positive element in . For this correspondence, we use the pairs with as above. Two pairs with gives a multiple of the order of . Now, the algorithm can be interpreted as translating the set of elements by , , , and checking if a lattice element is contained in any of these translates. If one visualizes this, one immediately sees that this method will eventually find the smallest non-zero element of the lattice. First, this depicts the lattice (gray dots) with its sublattice (black dots), with the set drawn in for :

The next figure depicts the translates of by :

One directly sees that the translates , 0}' title='k \in \N_{>0}' class='latex-inline' /> cover all positive integers, and that every positive integer is contained in exactly one translate. Moreover, one sees that if the first translate contains at most one lattice element, the first translate which contains a lattice element uniquely determines the smallest positive integer. Note that in case is the order of , then one can minimize the number of operations by chosing .

Now let us consider Terr’s modification of the baby-step giant-step algorithm; there, the situation is a bit more complicated. In Terr’s algorithm, the bound from above constantly changes, starting with . Written as pseudo-code, the algorithm looks like this:

Let and , and let and .
If for some , return .
Set , and set .
Compute and .
Go back to Step 2.

There is no obvious reason why this should work. Note that the test whether means that one translates by the exponent of , which turns out to be . One immediately gets the idea if one draws the first few translates:

This is another tiling of 0}' title='\N_{>0}' class='latex-inline' />, where every positive integer is contained in exactly one translate. This tiling has the property that the first time occurs for some is when the order of is found, and one no longer has to fix a bound before. The asymptotic complexity of this method is the same as the previous method in case , but in case is chosen the wrong way, the first algorithm will perform worse than the second. Another way to visualize the second agorithm is to depict the set together with , where and , for :

Infrastructures and Global Fields.

Felix Fontein — Thu, 23 Jul 2009 05:59:40 +0000

The following posts give an introduction to infrastructures and how to obtain these from global fields:

See also my article on infrastructures at Wikipedia.

n-dimensional Infrastructures.

Felix Fontein — Mon, 20 Jul 2009 08:40:46 +0000

For one-dimensional infrastructures, we have a circle together with a finite, non-empty set and an injective map . Now , where and is the one-dimensional lattice . Hence, one could say that an -dimensional infrastructure is a torus together with and as above. From the discussion in the remarks of this post we see that we need some kind of reduction map to define giant steps (and also -representations) in the one-dimensional case, even though there a pretty canonical reduction map is given. In the case of , we do not have something similar to a given positive direction. Moreover, definiting the “nearest” element of a finite subset of to some is even more complicated and offers more choices which appear more or less obvious. Only the selection of different norms on lead to several possible definitions of such a map. Hence, we should require such a map in the definition:

Definition.

Let be a lattice. Then, an -dimensional infrastructure is a non-empty finite set together with an injective map and another map satisfying .

Again, as in the one-dimensional case, one can define giant steps: Moreover, one gets the same relation between reduction maps and -representations, whence we define Then the map is a bijection, and we can use this bijection to equip with a group law by

Discrete Infrastructure.

We say that an -dimensional infrastructure with lattice is discrete if , and if does not depends on fractions. To make the last part more precise, define if , induces a map . Now, that does not depends on fractions simply means that factors through , i.e. that we can write with . Moreover, if in the following we specify discrete infrastructures, we often just define for values in . In that case, for elements , define . In case is discrete, consider the subset Then is an isomorphism.

Finite Abelian Groups as Infrastructures.

Let be a finite abelian group, generated by . Consider the relation lattice for , defined by Then is the kernel of , , and is a group isomorphism. Define , and (or, more precisely, ); then is an -dimensional infrastructure. Moreover, for , we have , whence equals the group operation of . Hence, every finite abelian group can be seen in a natural way as an infrastructure. Moreover, this shows that can be thought of as an analogue to the discrete logarithm map, and is an analogue of the power map . In particular, we obtained the goal described in the first post of this series: we found a generalization of the discrete logarithm problem to a non-associative algebraic structure. In the next post, I will how such infrastructures can be obtained from global fields; this gives a rich source of examples for -dimensional infrastructures.

What about baby steps?

Note that in the above discussion, I simply ignored baby steps. In the one-dimensional case, has a canonical direction (namely the positive one) and so has , whence saying “go to the next element” makes sense. Opposed to that, in , there are infinitely many directions, no one better than another. Even if we fix a direction, “go to the next element in that direction” seems to not really make sense. So far, I have not seen any definition of baby steps in this case which works for all -dimensional infrastructures. Note that in the case of infrastructures obtained from global fields, one has some kind of canonical baby steps (even though there are still some choices left). In fact, there are of them. To define them, though, one needs more information than just , and : one needs information about a -st dimension, both for constructing the reduction map and for defining baby steps.