Design and Implementation of a Homomorphic ... - Researcher

void addPrimes(const IndexSet& s);
Expand the index set by s. It is assumed that s is disjoint from the current index set. This is
an expensive operation, as it needs to convert to coefficient representation and back, in order
to determine the values in the added rows.
double addPrimesAndScale(const IndexSet& S);
Expand the index set by S, and multiply by q diff = ∏ i∈S p i. The set S is assumed to be
disjoint from the current index set. Returns log(q diff ). This operation is typically much faster
than addPrimes, since we can fill the added rows with zeros.
void removePrimes(const IndexSet& s);
Remove the primes p i with i ∈ s from the current index set.
void scaleDownToSet(const IndexSet& s, long ptxtSpace);
This is a modulus-switching operation. Let ∆ be the set of primes that are removed,
∆ = getIndexSet() \ s, and q diff = ∏ i∈∆ p i. This operation removes the primes p i , i ∈ ∆,
scales down the polynomial by a factor of q diff , and rounds so as to keep a mod ptxtSpace
unchanged.
We provide some conversion routines to convert polynomials from coefficient-representation
(NTL’s ZZX format) to DoubleCRT and back, using the constructor
DoubleCRT(const ZZX&, const FHEcontext&, const IndexSet&);
and the conversion function ZZX to ZZX(const DoubleCRT&). We also provide translation routines
between SingleCRT and DoubleCRT.
We support the usual set of arithmetic operations on DoubleCRT objects (e.g., addition, multiplication,
etc.), always working in A q for some modulus q. We only implemented the “destructive”
two-argument version of these operations, where one of the input arguments is modified to return
the result. These arithmetic operations can only be applied to DoubleCRT objects relative to the
same FHEcontext, else an error is raised.
On the other hand, the DoubleCRT class supports operations between objects with different
IndexSet’s, offering two options to resolve the differences: Our arithmetic operations take a boolean
flag matchIndexSets, when the flag is set to true (which is the default), the index-set of the result is
the union of the index-sets of the two arguments. When matchIndexSets=false then the index-set
of the result is the same as the index-set of *this, i.e., the argument that will contain the result
when the operation ends. The option matchIndexSets=true is slower, since it may require adding
primes to the two arguments. Below is a list of the arithmetic routines that we implemented:
DoubleCRT& Negate(const DoubleCRT& other); // *this = -other
DoubleCRT& Negate();
// *this = -*this;
DoubleCRT& operator+=(const DoubleCRT &other); // Addition
DoubleCRT& operator+=(const ZZX &poly); // expensive
DoubleCRT& operator+=(const ZZ &num);
DoubleCRT& operator+=(long num);
DoubleCRT& operator-=(const DoubleCRT &other); // Subtraction
DoubleCRT& operator-=(const ZZX &poly); // expensive
11