Design and Implementation of a Homomorphic ... - Researcher

2.6.2 The IndexMap class
The class template IndexMap implements a map of elements of type T, indexed by a dynamic
IndexSet. Additionally, it allows new elements of the map to be initialized in a flexible manner,
by providing an initialization function which is called whenever a new element (indexed by a new
index j) is added to the map.
Specifically, we have a helper class template IndexMapInit that stores a pointer to an
initialization function, and possibly also other parameters that the initialization function needs.
We then provide a constructor IndexMap(IndexMapInit* initObject=NULL) that associates
the given initialization object with the new IndexMap object. Thereafter, When a new index j is
added to the index set, an object t of type T is created using the default constructor for T, after
which the function initObject->init(t) is called.
In our library, we use an IndexMap to store the rows of the matrix of a Double-CRT object.
For these objects we have an initialization object that stores the value of φ(m), and the initialization
function, which is called whenever we add a new row, ensures that all the rows have length
exactly φ(m).
After initialization an IndexMap object provides the operator map[i] to access the type-T object
indexed by i (if i currently belongs to the IndexSet), as well as the methods map.insert(i) and
map.remove(i) to insert or delete a single data item indexed by i, and also map.insert(s) and
map.remove(s) to insert or delete a collection of data items indexed by the IndexSet s.
2.7 FHEcontext: Keeping the parameters
Objects in higher layers of our library are defined relative to some parameters, such as the integer
parameter m (that defines the groups Z ∗ m and Z ∗ m/ 〈2〉 and the ring A = Z[X]/Φ m (X)) and the
sequence of small primes that determine our modulus-chain. To allow convenient access to these
parameters, we define the class FHEcontext that keeps them all and provides access methods and
some utility functions.
One thing that’s included in FHEcontext is a vector of Cmodulus objects, holding the small
primes that define our modulus chain:
vector moduli;
// Cmodulus objects for the different primes
We provide access to the Cmodulus objects via context.ithModulus(i) (that returns a reference
of type const Cmodulus&), and to the small primes themselves via context.ithPrime(i)
(that returns a long). The FHEcontext includes also the various algebraic structures for plaintext
arithmetic, specifically we have the three data members:
PAlgebra zMstar; // The structure of Zm
∗
PAlgebraModTwo modTwo; // The structure of Z[X]/(Φ m (X), 2)
PAlgebraMod2r mod2r; // The structure of Z[X]/(Φ m (X), 2 r )
In addition to the above, the FHEcontext contains a few IndexSet objects, describing various
partitions of the index-set in the vector of moduli. These partitions are used when generating the
key-switching matrices in the public key, and when using them to actually perform key-switching
on ciphertexts.
One such partition is “ciphertext” vs. “special” primes: Freshly encrypted ciphertexts are
encrypted relative to a subset of the small primes, called the ciphertext primes. All other primes
are only used during key-switching, these are called the special primes. The ciphertext primes, in
9