Homomorphic Encryption:

Plaintext Data: m₁, m₂
     │           │
     ▼           ▼
Encryption: E(m₁), E(m₂)
     │           │
     └─────┬─────┘
           │
           ▼
Computation: E(m₁) ⊕ E(m₂) = E(m₁ ⊕ m₂)
           │
           ▼
Decryption: D(E(m₁ ⊕ m₂)) = m₁ ⊕ m₂

Where ⊕ represents some operation (addition, multiplication)

PHE Supports one operation:

Additive Homomorphic:
- Paillier: E(a) × E(b) = E(a + b)
- Properties: a + b encrypted
- Applications: Voting, e-voting

Multiplicative Homomorphic:
- RSA: E(a) × E(b) = E(a × b)
- Properties: a × b encrypted
- Applications: Secure multiplication

ElGamal:
- Supports multiplication
- Used in some cryptosystems
- Limited operation set

SHE Supports limited operations:
- Limited number of additions and multiplications
- Bootstrapping not required (or limited)
- Example: BGV, FV schemes
- Used when limited operations needed

Limitations:
- Noise grows with operations
- Requires noise management
- Limited depth circuits

FHE Supports unlimited operations:
- Unlimited additions and multiplications
- Bootstrapping to reduce noise
- Any computable function

FHE Schemes:
1. Gentry's Scheme (2009)
   - First FHE
   - Based on ideal lattices
   - Bootstrapping introduced

2. BFV (Brakerski-Fan-Vercauteren)
   - Ring-LWE based
   - Efficient for integer arithmetic
   - Widely adopted

3. CKKS (Cheon-Kim-Kim-Song)
   - Approximate arithmetic
   - Floating point operations
   - Machine learning applications

4. TFHE (Torus FHE)
   - Fast bootstrapping
   - Boolean circuits
   - Real-time applications

Lattice Problems:

1. Shortest Vector Problem (SVP):
   - Find shortest non-zero vector in lattice
   - NP-hard (worst case)

2. Learning With Errors (LWE):
   - Recover secret from noisy linear equations
   - Quantum-resistant
   - Basis for most FHE

3. Ring-LWE:
   - LWE over polynomial rings
   - More efficient
   - Used in FHE schemes

4. NTRU:
   - Lattice-based encryption
   - Fast and secure
   - Used in many applications

FHE Construction:

1. Encryption:
   c = (a, b = a × s + e + m)
   Where:
   - a: Random vector
   - s: Secret key
   - e: Error/noise
   - m: Message

2. Addition:
   c₁ + c₂ = (a₁+a₂, b₁+b₂)
   - Noise grows additively

3. Multiplication:
   c₁ × c₂ = (a₁×a₂, b₁×b₂)
   - Noise grows multiplicatively

4. Bootstrapping:
   - Refreshes ciphertext
   - Reduces noise
   - Enables unlimited operations

Confidential Transactions:

Traditional: Transaction amounts visible
FHE: Transaction amounts encrypted
Verification: Balance check on encrypted data

Benefits:
1. Privacy: Amounts hidden
2. Compliance: Still auditable
3. Integrity: No double-spending
4. Performance: Overheads manageable

Private Smart Contracts:

Problem: Smart contract data is public
Solution: FHE enables private data
But: Computation on encrypted data

Challenges:
- Performance overhead (1000×)
- Contract complexity
- State management
- Gas cost

Examples:
- Secret Network
- Aleph Zero
- Oasis Network

Private DeFi Applications:

1. Private Lending:
   - Borrowers' assets hidden
   - Lenders' positions private
   - Rates computed on encrypted data

2. Private DEX Trading:
   - Order sizes hidden
   - Price discovery private
   - Settlement verified

3. Private Governance:
   - Vote counts hidden
   - Proposals private
   - Results verifiable

4. Private NFTs:
   - Ownership private
   - Transaction history hidden
   - Provenance verifiable

FHE Performance Metrics:

1. Computation Overhead:
   - 1000-10000× slower than plaintext
   - Bootstrapping expensive
   - Circuit depth constraints

2. Memory Requirements:
   - 100-1000× larger ciphertexts
   - Key sizes: MB to GB
   - State: Growing with operations

3. Bandwidth:
   - Large ciphertexts
   - Slow transmission
   - Batch processing preferred

4. Practical Applications:
   - Simple operations
   - Batch processing
   - Pre-computation possible