public void BalancedEncodeDecodeInt32NET()
{
var modulus = new BigUInt("10000");
var encoder = new BalancedEncoder(modulus, 3);
var poly = encoder.Encode(0);
Assert.AreEqual(0, poly.GetSignificantCoeffCount());
Assert.IsTrue(poly.IsZero);
Assert.AreEqual(0, encoder.DecodeInt32(poly));
var poly1 = encoder.Encode(1);
Assert.AreEqual(1, poly1.GetSignificantCoeffCount());
Assert.AreEqual(modulus.BitCount, poly1.CoeffBitCount);
Assert.AreEqual("1", poly1.ToString());
Assert.AreEqual(1, encoder.DecodeInt32(poly1));
var poly2 = encoder.Encode(2);
Assert.AreEqual(2, poly2.GetSignificantCoeffCount());
Assert.AreEqual(modulus.BitCount, poly2.CoeffBitCount);
Assert.AreEqual("1x^1 + FFFF", poly2.ToString());
Assert.AreEqual(2, encoder.DecodeInt32(poly2));
var poly3 = encoder.Encode(3);
Assert.AreEqual(2, poly3.GetSignificantCoeffCount());
Assert.AreEqual(modulus.BitCount, poly3.CoeffBitCount);
Assert.AreEqual("1x^1", poly3.ToString());
Assert.AreEqual(3, encoder.DecodeInt32(poly3));
var poly4 = encoder.Encode(-1);
Assert.AreEqual(1, poly4.GetSignificantCoeffCount());
Assert.AreEqual(modulus.BitCount, poly4.CoeffBitCount);
Assert.AreEqual("FFFF", poly4.ToString());
Assert.AreEqual(-1, encoder.DecodeInt32(poly4));
var poly5 = encoder.Encode(-2);
Assert.AreEqual(2, poly5.GetSignificantCoeffCount());
Assert.AreEqual(modulus.BitCount, poly5.CoeffBitCount);
Assert.AreEqual("FFFFx^1 + 1", poly5.ToString());
Assert.AreEqual(-2, encoder.DecodeInt32(poly5));
var poly6 = encoder.Encode(-3);
Assert.AreEqual(2, poly6.GetSignificantCoeffCount());
Assert.AreEqual(modulus.BitCount, poly6.CoeffBitCount);
Assert.AreEqual("FFFFx^1", poly6.ToString());
Assert.AreEqual(-3, encoder.DecodeInt32(poly6));
var poly7 = encoder.Encode(-0x2671);
Assert.AreEqual(9, poly7.GetSignificantCoeffCount());
Assert.AreEqual(modulus.BitCount, poly7.CoeffBitCount);
for (int i = 0; i < 9; ++i)
{
Assert.AreEqual("FFFF", poly7[i].ToString());
}
Assert.AreEqual(-0x2671, encoder.DecodeInt32(poly7));
var poly8 = encoder.Encode(-4374);
Assert.AreEqual(9, poly8.GetSignificantCoeffCount());
Assert.AreEqual(modulus.BitCount, poly8.CoeffBitCount);
Assert.AreEqual("FFFF", poly8[8].ToString());
Assert.AreEqual("1", poly8[7].ToString());
for (int i = 0; i < 7; ++i)
{
Assert.IsTrue(poly8[i].IsZero);
}
Assert.AreEqual(-4374, encoder.DecodeInt32(poly8));
var poly9 = encoder.Encode(-0xD4EB);
Assert.AreEqual(11, poly9.GetSignificantCoeffCount());
Assert.AreEqual(modulus.BitCount, poly9.CoeffBitCount);
for (int i = 0; i < 11; ++i)
{
if (i % 3 == 1)
{
Assert.AreEqual("FFFF", poly9[i].ToString());
}
else if (i % 3 == 0)
{
Assert.IsTrue(poly9[i].IsZero);
}
else
{
Assert.AreEqual("1", poly9[i].ToString());
}
}
Assert.AreEqual(-0xD4EB, encoder.DecodeInt32(poly9));
var poly10 = encoder.Encode(-30724);
Assert.AreEqual(11, poly10.GetSignificantCoeffCount());
Assert.AreEqual(modulus.BitCount, poly10.CoeffBitCount);
Assert.AreEqual("FFFF", poly10[10].ToString());
Assert.AreEqual("1", poly10[9].ToString());
Assert.AreEqual("1", poly10[8].ToString());
Assert.AreEqual("1", poly10[7].ToString());
Assert.IsTrue(poly10[6].IsZero);
Assert.IsTrue(poly10[5].IsZero);
Assert.AreEqual("FFFF", poly10[4].ToString());
Assert.AreEqual("FFFF", poly10[3].ToString());
Assert.IsTrue(poly10[2].IsZero);
Assert.AreEqual("1", poly10[1].ToString());
Assert.AreEqual("FFFF", poly10[0].ToString());
Assert.AreEqual(-30724, encoder.DecodeInt32(poly10));
modulus.Set("FFFF");
var encoder2 = new BalancedEncoder(modulus, 7);
var poly12 = new BigPoly(6, 16);
poly12[0].Set(1);
poly12[1].Set("FFFE"); // -1
poly12[2].Set("FFFD"); // -2
poly12[3].Set("8000"); // -32767
poly12[4].Set("7FFF"); // 32767
poly12[5].Set("7FFE"); // 32766
Assert.AreEqual(1 + -1 * 7 + -2 * 49 + -32767 * 343 + 32767 * 2401 + 32766 * 16807, encoder2.DecodeInt32(poly12));
}
static void ExampleBasics()
{
PrintExampleBanner("Example: Basics");
// In this example we demonstrate using some of the basic arithmetic operations on integers.
// Create encryption parameters.
var parms = new EncryptionParameters();
/*
* First choose the polynomial modulus. This must be a power-of-2 cyclotomic polynomial,
* i.e. a polynomial of the form "1x^(power-of-2) + 1". We recommend using polynomials of
* degree at least 1024.
*/
parms.PolyModulus.Set("1x^4096 + 1");
/*
* Next choose the coefficient modulus. The values we recommend to be used are:
*
* [ degree(poly_modulus), coeff_modulus ]
* [ 1024, "FFFFFFFFC001" ],
* [ 2048, "7FFFFFFFFFFFFFFFFFFF001"],
* [ 4096, "7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"],
* [ 8192, "1FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFC000001"],
* [ 16384, "7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000000001"].
*
* These can be conveniently accessed using ChooserEvaluator.DefaultParameterOptions(),
* which returns the above list of options as a Dictionary, keyed by the degree of the polynomial modulus.
*/
parms.CoeffModulus.Set(ChooserEvaluator.DefaultParameterOptions[4096]);
/*
* Now we set the plaintext modulus. This can be any integer, even though here we take it to be a power of two.
* A larger plaintext modulus causes the noise to grow faster in homomorphic multiplication, and
* also lowers the maximum amount of noise in ciphertexts that the system can tolerate.
* On the other hand, a larger plaintext modulus typically allows for better homomorphic integer arithmetic,
* although this depends strongly on which encoder is used to encode integers into plaintext polynomials.
*/
parms.PlainModulus.Set(1 << 10);
/*
* The decomposition bit count affects the behavior of the relinearization (key switch) operation,
* which is typically performed after each homomorphic multiplication. A smaller decomposition
* bit count makes relinearization slower, but improves the noise growth behavior on multiplication.
* Conversely, a larger decomposition bit count makes homomorphic multiplication faster at the cost
* of increased noise growth.
*/
parms.DecompositionBitCount = 32;
/*
* We use a constant standard deviation for the error distribution. Using a larger standard
* deviation will result in larger noise growth, but in theory should make the system more secure.
*/
parms.NoiseStandardDeviation = ChooserEvaluator.DefaultNoiseStandardDeviation;
// For the bound on the error distribution we can take for instance 5 * standard_deviation.
parms.NoiseMaxDeviation = 5 * parms.NoiseStandardDeviation;
Console.WriteLine("Encryption parameters specify {0} coefficients with {1} bits per coefficient",
parms.PolyModulus.GetSignificantCoeffCount(), parms.CoeffModulus.GetSignificantBitCount());
// Encode two integers as polynomials.
const int value1 = 5;
const int value2 = -7;
var encoder = new BalancedEncoder(parms.PlainModulus);
var encoded1 = encoder.Encode(value1);
var encoded2 = encoder.Encode(value2);
Console.WriteLine("Encoded {0} as polynomial {1}", value1, encoded1);
Console.WriteLine("Encoded {0} as polynomial {1}", value2, encoded2);
// Generate keys.
Console.WriteLine("Generating keys...");
var generator = new KeyGenerator(parms);
generator.Generate();
Console.WriteLine("... key generation completed");
var publicKey = generator.PublicKey;
var secretKey = generator.SecretKey;
var evaluationKeys = generator.EvaluationKeys;
//Console.WriteLine("Public Key = {0}", publicKey);
//Console.WriteLine("Secret Key = {0}", secretKey);
// Encrypt values.
Console.WriteLine("Encrypting values...");
var encryptor = new Encryptor(parms, publicKey);
var encrypted1 = encryptor.Encrypt(encoded1);
var encrypted2 = encryptor.Encrypt(encoded2);
// Perform arithmetic on encrypted values.
Console.WriteLine("Performing encrypted arithmetic...");
var evaluator = new Evaluator(parms, evaluationKeys);
Console.WriteLine("... Performing negation...");
var encryptedNegated1 = evaluator.Negate(encrypted1);
Console.WriteLine("... Performing addition...");
var encryptedSum = evaluator.Add(encrypted1, encrypted2);
Console.WriteLine("... Performing subtraction...");
var encryptedDiff = evaluator.Sub(encrypted1, encrypted2);
Console.WriteLine("... Performing multiplication...");
var encryptedProduct = evaluator.Multiply(encrypted1, encrypted2);
// Decrypt results.
Console.WriteLine("Decrypting results...");
var decryptor = new Decryptor(parms, secretKey);
var decrypted1 = decryptor.Decrypt(encrypted1);
var decrypted2 = decryptor.Decrypt(encrypted2);
var decryptedNegated1 = decryptor.Decrypt(encryptedNegated1);
var decryptedSum = decryptor.Decrypt(encryptedSum);
var decryptedDiff = decryptor.Decrypt(encryptedDiff);
var decryptedProduct = decryptor.Decrypt(encryptedProduct);
// Decode results.
var decoded1 = encoder.DecodeInt32(decrypted1);
var decoded2 = encoder.DecodeInt32(decrypted2);
var decodedNegated1 = encoder.DecodeInt32(decryptedNegated1);
var decodedSum = encoder.DecodeInt32(decryptedSum);
var decodedDiff = encoder.DecodeInt32(decryptedDiff);
var decodedProduct = encoder.DecodeInt32(decryptedProduct);
// Display results.
Console.WriteLine("{0} after encryption/decryption = {1}", value1, decoded1);
Console.WriteLine("{0} after encryption/decryption = {1}", value2, decoded2);
Console.WriteLine("encrypted negate of {0} = {1}", value1, decodedNegated1);
Console.WriteLine("encrypted addition of {0} and {1} = {2}", value1, value2, decodedSum);
Console.WriteLine("encrypted subtraction of {0} and {1} = {2}", value1, value2, decodedDiff);
Console.WriteLine("encrypted multiplication of {0} and {1} = {2}", value1, value2, decodedProduct);
// How did the noise grow in these operations?
var maxNoiseBitCount = Utilities.InherentNoiseMax(parms).GetSignificantBitCount();
Console.WriteLine("Noise in encryption of {0}: {1}/{2} bits", value1, Utilities.InherentNoise(encrypted1, parms, secretKey).GetSignificantBitCount(), maxNoiseBitCount);
Console.WriteLine("Noise in encryption of {0}: {1}/{2} bits", value2, Utilities.InherentNoise(encrypted1, parms, secretKey).GetSignificantBitCount(), maxNoiseBitCount);
Console.WriteLine("Noise in the sum: {0}/{1} bits", Utilities.InherentNoise(encryptedSum, parms, secretKey).GetSignificantBitCount(), maxNoiseBitCount);
Console.WriteLine("Noise in the product: {0}/{1} bits", Utilities.InherentNoise(encryptedProduct, parms, secretKey).GetSignificantBitCount(), maxNoiseBitCount);
}
public void BalancedEncodeDecodeInt32NET()
{
var modulus = new SmallModulus(0x10000);
var encoder = new BalancedEncoder(modulus, 3, MemoryPoolHandle.New());
var poly = encoder.Encode(0);
Assert.AreEqual(0, poly.SignificantCoeffCount());
Assert.IsTrue(poly.IsZero);
Assert.AreEqual(0, encoder.DecodeInt32(poly));
var poly1 = encoder.Encode(1);
Assert.AreEqual(1, poly1.SignificantCoeffCount());
Assert.AreEqual("1", poly1.ToString());
Assert.AreEqual(1, encoder.DecodeInt32(poly1));
var poly2 = encoder.Encode(2);
Assert.AreEqual(2, poly2.SignificantCoeffCount());
Assert.AreEqual("1x^1 + FFFF", poly2.ToString());
Assert.AreEqual(2, encoder.DecodeInt32(poly2));
var poly3 = encoder.Encode(3);
Assert.AreEqual(2, poly3.SignificantCoeffCount());
Assert.AreEqual("1x^1", poly3.ToString());
Assert.AreEqual(3, encoder.DecodeInt32(poly3));
var poly4 = encoder.Encode(-1);
Assert.AreEqual(1, poly4.SignificantCoeffCount());
Assert.AreEqual("FFFF", poly4.ToString());
Assert.AreEqual(-1, encoder.DecodeInt32(poly4));
var poly5 = encoder.Encode(-2);
Assert.AreEqual(2, poly5.SignificantCoeffCount());
Assert.AreEqual("FFFFx^1 + 1", poly5.ToString());
Assert.AreEqual(-2, encoder.DecodeInt32(poly5));
var poly6 = encoder.Encode(-3);
Assert.AreEqual(2, poly6.SignificantCoeffCount());
Assert.AreEqual("FFFFx^1", poly6.ToString());
Assert.AreEqual(-3, encoder.DecodeInt32(poly6));
var poly7 = encoder.Encode(-0x2671);
Assert.AreEqual(9, poly7.SignificantCoeffCount());
for (int i = 0; i < 9; ++i)
{
Assert.AreEqual(0xFFFFUL, poly7[i]);
}
Assert.AreEqual(-0x2671, encoder.DecodeInt32(poly7));
var poly8 = encoder.Encode(-4374);
Assert.AreEqual(9, poly8.SignificantCoeffCount());
Assert.AreEqual(0xFFFFUL, poly8[8]);
Assert.AreEqual(1UL, poly8[7]);
for (int i = 0; i < 7; ++i)
{
Assert.IsTrue(poly8[i] == 0);
}
Assert.AreEqual(-4374, encoder.DecodeInt32(poly8));
var poly9 = encoder.Encode(-0xD4EB);
Assert.AreEqual(11, poly9.SignificantCoeffCount());
for (int i = 0; i < 11; ++i)
{
if (i % 3 == 1)
{
Assert.AreEqual(0xFFFFUL, poly9[i]);
}
else if (i % 3 == 0)
{
Assert.IsTrue(poly9[i] == 0);
}
else
{
Assert.AreEqual(1UL, poly9[i]);
}
}
Assert.AreEqual(-0xD4EB, encoder.DecodeInt32(poly9));
var poly10 = encoder.Encode(-30724);
Assert.AreEqual(11, poly10.SignificantCoeffCount());
Assert.AreEqual(0xFFFFUL, poly10[10]);
Assert.AreEqual(1UL, poly10[9]);
Assert.AreEqual(1UL, poly10[8]);
Assert.AreEqual(1UL, poly10[7]);
Assert.IsTrue(poly10[6] == 0);
Assert.IsTrue(poly10[5] == 0);
Assert.AreEqual(0xFFFFUL, poly10[4]);
Assert.AreEqual(0xFFFFUL, poly10[3]);
Assert.IsTrue(poly10[2] == 0);
Assert.AreEqual(1UL, poly10[1]);
Assert.AreEqual(0xFFFFUL, poly10[0]);
Assert.AreEqual(-30724, encoder.DecodeInt32(poly10));
modulus.Set(0xFFFF);
var encoder2 = new BalancedEncoder(modulus, 7, MemoryPoolHandle.New());
var poly12 = new Plaintext(6);
poly12[0] = 1;
poly12[1] = 0xFFFE; // -1
poly12[2] = 0xFFFD; // -2
poly12[3] = 0x8000; // -32767
poly12[4] = 0x7FFF; // 32767
poly12[5] = 0x7FFE; // 32766
Assert.AreEqual(1 + -1 * 7 + -2 * 49 + -32767 * 343 + 32767 * 2401 + 32766 * 16807, encoder2.DecodeInt32(poly12));
var encoder4 = new BalancedEncoder(modulus, 6, MemoryPoolHandle.New());
poly8 = new Plaintext(4);
poly8[0] = 5;
poly8[1] = 4;
poly8[2] = 3;
poly8[3] = (modulus.Value - 2);
Int32 value = 5 + 4 * 6 + 3 * 36 - 2 * 216;
Assert.AreEqual(value, encoder4.DecodeInt32(poly8));
var encoder5 = new BalancedEncoder(modulus, 10, MemoryPoolHandle.New());
poly9 = new Plaintext(4);
poly9[0] = 1;
poly9[1] = 2;
poly9[2] = 3;
poly9[3] = 4;
value = 4321;
Assert.AreEqual(value, encoder5.DecodeInt32(poly9));
value = -1234;
poly10.Set(encoder2.Encode(value));
Assert.AreEqual(5, poly10.SignificantCoeffCount());
Assert.IsTrue(value.Equals(encoder2.DecodeInt32(poly10)));
value = -1234;
var poly11 = encoder4.Encode(value);
Assert.AreEqual(5, poly11.SignificantCoeffCount());
Assert.AreEqual(value, encoder4.DecodeInt32(poly11));
value = -1234;
poly12.Set(encoder5.Encode(value));
Assert.AreEqual(4, poly12.SignificantCoeffCount());
Assert.IsTrue(value.Equals(encoder5.DecodeInt32(poly12)));
}
public static void ExampleBasics()
{
PrintExampleBanner("Example: Basics");
/*
* In this example we demonstrate using some of the basic arithmetic operations on integers.
*
* SEAL uses the Fan-Vercauteren (FV) homomorphic encryption scheme. We refer to
* https://eprint.iacr.org/2012/144 for full details on how the FV scheme works.
*/
// Create encryption parameters.
var parms = new EncryptionParameters();
/*
* First choose the polynomial modulus. This must be a power-of-2 cyclotomic polynomial,
* i.e. a polynomial of the form "1x^(power-of-2) + 1". We recommend using polynomials of
* degree at least 1024.
*/
parms.PolyModulus.Set("1x^2048 + 1");
/*
* Next choose the coefficient modulus. The values we recommend to be used are:
*
* [ degree(PolyModulus), CoeffModulus ]
* [ 1024, "FFFFFFF00001" ],
* [ 2048, "3FFFFFFFFFFFFFFFFFF00001"],
* [ 4096, "3FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFC0000001"],
* [ 8192, "7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE00000001"],
* [ 16384, "7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000000001"].
*
* These can be conveniently accessed using ChooserEvaluator.DefaultParameterOptions, which returns
* the above list of options as a Dictionary, keyed by the degree of the polynomial modulus.
*
* The user can also relatively easily choose their custom coefficient modulus. It should be a prime number
* of the form 2^A - 2^B + 1, where A > B > degree(PolyModulus). Moreover, B should be as small as possible
* for improved efficiency in modular reduction. For security, we recommend strictly adhering to the following
* size bounds: (see Lepoint-Naehrig (2014) [https://eprint.iacr.org/2014/062])
* /-----------------------------------------------------------------\
| PolyModulus | CoeffModulus bound | default CoeffModulus |
| -------------|--------------------|-----------------------------|
| 1x^1024 + 1 | 48 bits | 2^48 - 2^20 + 1 (47 bits) |
| 1x^2048 + 1 | 96 bits | 2^94 - 2^20 + 1 (93 bits) |
| 1x^4096 + 1 | 192 bits | 2^190 - 2^30 + 1 (189 bits) |
| 1x^8192 + 1 | 384 bits | 2^383 - 2^33 + 1 (382 bits) |
| 1x^16384 + 1 | 768 bits | 2^767 - 2^56 + 1 (766 bits) |
\-----------------------------------------------------------------/
|
| The size of CoeffModulus affects the upper bound on the "inherent noise" that a ciphertext can contain
| before becoming corrupted. More precisely, every ciphertext starts with a certain amount of noise in it,
| which grows in all homomorphic operations - in particular in multiplication. Once a ciphertext contains
| too much noise, it becomes impossible to decrypt. The upper bound on the noise is roughly given by
| CoeffModulus/PlainModulus (see below), so increasing CoeffModulus will allow the user to perform more
| homomorphic operations on the ciphertexts without corrupting them. We would like to stress, however, that
| the bounds given above for CoeffModulus should absolutely not be exceeded.
*/
parms.CoeffModulus.Set(ChooserEvaluator.DefaultParameterOptions[2048]);
/*
* Now we set the plaintext modulus. This can be any positive integer, even though here we take it to be a
* power of two. A larger plaintext modulus causes the noise to grow faster in homomorphic multiplication,
* and also lowers the maximum amount of noise in ciphertexts that the system can tolerate (see above).
* On the other hand, a larger plaintext modulus typically allows for better homomorphic integer arithmetic,
* although this depends strongly on which encoder is used to encode integers into plaintext polynomials.
*/
parms.PlainModulus.Set(1 << 8);
Console.WriteLine("Encryption parameters specify {0} coefficients with {1} bits per coefficient",
parms.PolyModulus.GetSignificantCoeffCount(), parms.CoeffModulus.GetSignificantBitCount());
/*
* Plaintext elements in the FV scheme are polynomials (represented by the BigPoly class) with coefficients
* integers modulo plain_modulus. To encrypt integers instead, one must use an "encoding scheme", i.e.
* a specific way of representing integers as such polynomials. SEAL comes with a few basic encoders:
*
* BinaryEncoder:
* Encodes positive integers as plaintext polynomials where the coefficients are either 0 or 1 according
* to the binary representation of the integer to be encoded. Decoding amounts to evaluating the polynomial
* at x=2. For example, the integer 26 = 2^4 + 2^3 + 2^1 is encoded as the polynomial 1x^4 + 1x^3 + 1x^1.
* Negative integers are encoded similarly but with each coefficient coefficient of the polynomial replaced
* with its negative modulo PlainModulus.
*
* BalancedEncoder:
* Given an odd integer base b, encodes integers as plaintext polynomials where the coefficients are according
* to the "balanced" base b representation of the integer to be encoded, i.e. where each coefficient is in the
* range -(b-1)/2,...,(b-1)/2. Decoding amounts to evaluating the polynomial at x=b. For example, when b=3 the
* integer 25 = 3^3 - 3^1 + 3^0 is encoded as the polynomial 1x^3 - 1x^1 + 1.
*
* BinaryFractionalEncoder:
* Encodes rational numbers as follows. First represent the number in binary, possibly truncating an infinite
* fractional part to some fixed precision, e.g. 26.75 = 2^4 + 2^3 + 2^1 + 2^(-1) + 2^(-2). For the sake of
* the example, suppose PolyModulus is 1x^1024 + 1. Next represent the integer part of the number in the same
* was as in BinaryEncoder. Finally, represent the fractional part in the leading coefficients of the polynomial,
* but when doing so invert the signs of the coefficients. So in this example we would represent 26.75 as the
* polynomial -1x^1023 - 1x^1022 + 1x^4 + 1x^3 + 1x^1. The negative coefficients of the polynomial will again be
* represented as their negatives modulo PlainModulus.
*
* BalancedFractionalEncoder:
* Same as BinaryFractionalEncoder, except instead of using base 2 uses any odd base b and balanced
* representatives for the coefficients, i.e. integers in the range -(b-1)/2,...,(b-1)/2.
*
* PolyCRTBuilder:
* If PolyModulus is 1x^n + 1, PolyCRTBuilder allows "batching" of n plaintext integers modulo PlainModulus
* into one plaintext polynomial, where homomorphic operations can be carried out very efficiently in a SIMD
* manner by operating on such a "composed" plaintext or ciphertext polynomials. For full details on this very
* powerful technique we recommend https://eprint.iacr.org/2012/565.pdf and https://eprint.iacr.org/2011/133.
*
* A crucial fact to understand is that when homomorphic operations are performed on ciphertexts, they will
* carry over to the underlying plaintexts, and as a result of additions and multiplications the coefficients
* in the plaintext polynomials will increase from what they originally were in freshly encoded polynomials.
* This becomes a problem when the coefficients reach the size of PlainModulus, in which case they will get
* automatically reduced modulo PlainModulus, and might render the underlying plaintext polynomial impossible
* to be correctly decoded back into an integer or rational number. Therefore, it is typically crucial to
* have a good sense of how large the coefficients will grow in the underlying plaintext polynomials when
* homomorphic computations are carried out on the ciphertexts, and make sure that PlainModulus is chosen to
* be at least as large as this number.
*/
// Encode two integers as polynomials.
const int value1 = 5;
const int value2 = -7;
var encoder = new BalancedEncoder(parms.PlainModulus);
var encoded1 = encoder.Encode(value1);
var encoded2 = encoder.Encode(value2);
Console.WriteLine("Encoded {0} as polynomial {1}", value1, encoded1);
Console.WriteLine("Encoded {0} as polynomial {1}", value2, encoded2);
// Generate keys.
Console.WriteLine("Generating keys...");
var generator = new KeyGenerator(parms);
generator.Generate();
Console.WriteLine("... key generation completed");
var publicKey = generator.PublicKey;
var secretKey = generator.SecretKey;
//Console.WriteLine("Public Key = {0}", publicKey);
//Console.WriteLine("Secret Key = {0}", secretKey);
// Encrypt values.
Console.WriteLine("Encrypting values...");
var encryptor = new Encryptor(parms, publicKey);
var encrypted1 = encryptor.Encrypt(encoded1);
var encrypted2 = encryptor.Encrypt(encoded2);
// Perform arithmetic on encrypted values.
Console.WriteLine("Performing encrypted arithmetic...");
var evaluator = new Evaluator(parms);
Console.WriteLine("... Performing negation...");
var encryptedNegated1 = evaluator.Negate(encrypted1);
Console.WriteLine("... Performing addition...");
var encryptedSum = evaluator.Add(encrypted1, encrypted2);
Console.WriteLine("... Performing subtraction...");
var encryptedDiff = evaluator.Sub(encrypted1, encrypted2);
Console.WriteLine("... Performing multiplication...");
var encryptedProduct = evaluator.Multiply(encrypted1, encrypted2);
// Decrypt results.
Console.WriteLine("Decrypting results...");
var decryptor = new Decryptor(parms, secretKey);
var decrypted1 = decryptor.Decrypt(encrypted1);
var decrypted2 = decryptor.Decrypt(encrypted2);
var decryptedNegated1 = decryptor.Decrypt(encryptedNegated1);
var decryptedSum = decryptor.Decrypt(encryptedSum);
var decryptedDiff = decryptor.Decrypt(encryptedDiff);
var decryptedProduct = decryptor.Decrypt(encryptedProduct);
// Decode results.
var decoded1 = encoder.DecodeInt32(decrypted1);
var decoded2 = encoder.DecodeInt32(decrypted2);
var decodedNegated1 = encoder.DecodeInt32(decryptedNegated1);
var decodedSum = encoder.DecodeInt32(decryptedSum);
var decodedDiff = encoder.DecodeInt32(decryptedDiff);
var decodedProduct = encoder.DecodeInt32(decryptedProduct);
// Display results.
Console.WriteLine("{0} after encryption/decryption = {1}", value1, decoded1);
Console.WriteLine("{0} after encryption/decryption = {1}", value2, decoded2);
Console.WriteLine("encrypted negate of {0} = {1}", value1, decodedNegated1);
Console.WriteLine("encrypted addition of {0} and {1} = {2}", value1, value2, decodedSum);
Console.WriteLine("encrypted subtraction of {0} and {1} = {2}", value1, value2, decodedDiff);
Console.WriteLine("encrypted multiplication of {0} and {1} = {2}", value1, value2, decodedProduct);
// How did the noise grow in these operations?
var maxNoiseBitCount = Utilities.InherentNoiseMax(parms).GetSignificantBitCount();
Console.WriteLine("Noise in encryption of {0}: {1}/{2} bits", value1, Utilities.InherentNoise(encrypted1, parms, secretKey).GetSignificantBitCount(), maxNoiseBitCount);
Console.WriteLine("Noise in encryption of {0}: {1}/{2} bits", value2, Utilities.InherentNoise(encrypted1, parms, secretKey).GetSignificantBitCount(), maxNoiseBitCount);
Console.WriteLine("Noise in the sum: {0}/{1} bits", Utilities.InherentNoise(encryptedSum, parms, secretKey).GetSignificantBitCount(), maxNoiseBitCount);
Console.WriteLine("Noise in the product: {0}/{1} bits", Utilities.InherentNoise(encryptedProduct, parms, secretKey).GetSignificantBitCount(), maxNoiseBitCount);
}
