Concrete Core

This crate contains low-level implementations of homomorphic operators used in the concrete library.

⚠ Warning ⚠

This crate assumes that the user is comfortable with the theory behind FHE. If you prefer to use a simpler API, that will perform sanity checks on your behalf, the higher-level concrete crate should have your back.

Example

Here is a small example of how one could use concrete-core to perform a simple operation homomorphically:

```rust // This examples shows how to multiply a secret value by a public one homomorphically. First // we import the proper symbols: use concretecore::crypto::encoding::{RealEncoder, Cleartext, Encoder, Plaintext}; use concretecore::crypto::secret::LweSecretKey; use concretecore::crypto::LweDimension; use concretecore::crypto::lwe::LweCiphertext; use concrete_core::math::dispersion::LogStandardDev;

// We initialize an encoder that will allow us to turn cleartext values into plaintexts. let encoder = RealEncoder{offset: 0., delta: 100.}; // Our secret value will be 10., let cleartext = Cleartext(10.); let public_multiplier = Cleartext(5); // We encode our cleartext let plaintext = encoder.encode(cleartext);

// We generate a new secret key which is used to encrypt the message let secretkeysize = LweDimension(710); let secretkey = LweSecretKey::generate(secretkey_size);

// We allocate a ciphertext and encrypt the plaintext with a secure parameter let mut ciphertext = LweCiphertext::allocate(0u32, secretkeysize.tolwesize()); secretkey.encryptlwe( &mut ciphertext, &plaintext, LogStandardDev::fromlogstandard_dev(-17.) );

// We perform the homomorphic operation: ciphertext.updatewithscalarmul(publicmultiplier);

// We decrypt the message let mut outputplaintext = Plaintext(0u32); secretkey.decryptlwe(&mut outputplaintext, &ciphertext); let outputcleartext = encoder.decode(outputplaintext);

// We check that the result is as expected ! asserteq!((outputcleartext.0 - 50.).abs() < 0.01); ```