Hand a server your salaries, scans or model inputs and get real answers back, while the server itself sees nothing but noise.
You want to use a cloud service, a hospital analytics pipeline or someone else’s model — but handing over raw data is the price of admission, and sometimes the contract or the law says you cannot pay it. Fully homomorphic encryption (FHE) removes that trade: the server does the arithmetic on ciphertexts and never holds a key. Start with the schemes that got partway there — RSA, ElGamal, Paillier — then build the lattice machinery underneath modern FHE: learning with errors (LWE), its ring variant, and the noise budget every operation spends. From there you implement the four workhorse schemes and learn when each one wins: Brakerski/Fan-Vercauteren (BFV) and Brakerski-Gentry-Vaikuntanathan (BGV) for exact integer arithmetic, Cheon-Kim-Kim-Song (CKKS) for approximate real numbers and neural network inference, and fast fully homomorphic encryption over the torus (TFHE) for Boolean circuits and lookup tables. Bootstrapping — Gentry’s trick for refreshing a worn-out ciphertext — turns bounded depth into unbounded computation. You finish in OpenFHE, Microsoft SEAL and Concrete, tuning real parameters and benchmarking a pipeline that decrypts only on the client.
Built by Lakshya Kumar
Paste this into any AI chat. Fill in the bracketed parts with your context — you'll get back a straight answer on whether this belongs on your plate.
We grant free access case-by-case — students, career-switchers, builders on a tight budget. Sign in to send us a note.
Sign in to applyFinished the tasks? Take the prompt to your AI and get tested on it. We copy the prompt and open the app — just paste it in.
Paillier and ElGamal each bend one operation through encryption — enough to run a private election before any lattice math appears.
Every operation spends a hidden error budget; measure it and you can predict exactly when your circuit stops decrypting correctly.
Add and multiply encrypted whole numbers with zero rounding error, thousands of values at a time inside one packed ciphertext.
Fix the circuit depth at setup and BGV tames noise level by level, so you can reason about cost in levels rather than fragile bit counts.
Trade exactness for reach — approximate arithmetic on encrypted floats is what makes private model inference actually run.
Refreshing after every gate makes branches, comparisons and lookup tables cheap — the exact things polynomial schemes cannot touch.
The single operation that removes the depth ceiling: decrypt homomorphically, and your computation can run as long as you will pay for it.
Choose a scheme, tune parameters until the noise budget holds, and ship a pipeline that only ever decrypts on the client side.
Size up private inference, private lookups and genomic privacy, and learn to estimate latency from a circuit before you commit to a design.
Complete all modules, then submit the required number of capstone projects. Each must earn a passing rating from an admin reviewer.
Choose one: implement a private mean/variance computation for 100 floats using CKKS (OpenFHE); implement a private comparison circuit for 8-bit integers using TFHE (Concrete); or implement a private voting tally with threshold decryption using Paillier. Include benchmarks, a noise-budget analysis, and a 5-page report on when your chosen scheme is appropriate.
I'm studying Homomorphic Encryption: Ring-LWE hardness and noise management, the BFV scheme for exact integer arithmetic, BGV, CKKS for approximate arithmetic, TFHE for Boolean circuits via programmable bootstrapping, bootstrapping (Gentry 2009), multi-key FHE, threshold decryption, FHE libraries (OpenFHE, SEAL, Zama Concrete), and applications in private ML, PIR, genomics, and blockchain. Context: 1. My goal: [e.g. "use FHE for private ML inference", "understand TFHE for a blockchain project", "build a privacy-preserving system"] 2. My background: [e.g. "completed Advanced Cryptography module", "engineer wanting to use FHE libraries"] 3. One concept to understand: [e.g. "how does CKKS rescaling work?", "when should I choose TFHE vs BFV?"] Answer: - For (3): the precise mathematical explanation and a Python snippet showing the effect. - What's the minimal path through this course for my goal? - What FHE scheme and library for my use case, and what are the performance implications?
Build a service that computes statistics (mean, variance, count) on encrypted data without seeing the plaintext. Use BFV or CKKS for the encryption layer; clients encrypt + upload; server aggregates + returns encrypted result. Benchmark for 10k records.
Implement a 2-party PSI protocol: both parties have sets of 100k items; compute the intersection without revealing non-intersecting items. Compare PSI-via-FHE to a hash-based PSI; document the trade-offs.
Run inference for a small ML model (logistic regression or 2-layer neural net) under FHE. Client encrypts input; server runs inference; client decrypts the result. Benchmark the latency for one prediction; document the accuracy degradation vs floating-point.
Take a real-world privacy use case (e.g., census-style aggregate queries). Implement two solutions: differential-privacy (with Laplace noise) and FHE. Compare query accuracy, latency, and trust assumptions. Produce a recommendation memo for which technique to ship.
The TFHE paper. Read after Module 7.