CPU: Intel Core i9-12900K @ 3.2GHz (24 threads)
RAM: 64GB DDR5-5600
OS: Ubuntu 22.04 LTS
Go: 1.21.5
Compiler: go build -O3

// CKKS Memory Footprint (N=2^14)
Secret Key:        4 MB
Public Key:      128 MB
Relin Key:       384 MB
Galois Key:      384 MB per element
Ciphertext:       16 MB (per level)
Plaintext:         8 MB
Bootstrapping:   512 MB (temporary)

// Create a pool for ciphertext reuse
type CiphertextPool struct {
    pool sync.Pool
}

func NewCiphertextPool(params Parameters) *CiphertextPool {
    return &CiphertextPool{
        pool: sync.Pool{
            New: func() interface{} {
                return ckks.NewCiphertext(params, 1, params.MaxLevel())
            },
        },
    }
}

func (p *CiphertextPool) Get() *Ciphertext {
    return p.pool.Get().(*Ciphertext)
}

func (p *CiphertextPool) Put(ct *Ciphertext) {
    ct.Level = params.MaxLevel() // Reset level
    p.pool.Put(ct)
}

// Prefer in-place operations to reduce allocations
// Bad: Creates new ciphertext
ctSum, _ := evaluator.AddNew(ct1, ct2)

// Good: Reuses existing ciphertext
evaluator.Add(ct1, ct2, ct1) // Result stored in ct1

// Allocate evaluation keys only when needed
type LazyEvaluator struct {
    params Parameters
    rlk    *RelinearizationKey
    gks    map[uint64]*GaloisKey
    mu     sync.RWMutex
}

func (e *LazyEvaluator) GetGaloisKey(galEl uint64) *GaloisKey {
    e.mu.RLock()
    if gk, ok := e.gks[galEl]; ok {
        e.mu.RUnlock()
        return gk
    }
    e.mu.RUnlock()

    e.mu.Lock()
    defer e.mu.Unlock()
    // Generate key if not exists
    gk := kgen.GenGaloisKeyNew(galEl, sk)
    e.gks[galEl] = gk
    return gk
}

// NTT operations are parallelized internally
// Controlled by GOMAXPROCS
runtime.GOMAXPROCS(runtime.NumCPU())

// For N=2^14, NTT parallelization:
// 1 thread:  4.2ms
// 4 threads: 1.3ms (3.2x speedup)
// 8 threads: 0.8ms (5.3x speedup)
// 16 threads: 0.6ms (7x speedup)

// Process multiple ciphertexts in parallel
func ParallelEvaluate(eval Evaluator, cts []*Ciphertext, f func(*Ciphertext) error) error {
    errChan := make(chan error, len(cts))
    var wg sync.WaitGroup

    for i := range cts {
        wg.Add(1)
        go func(ct *Ciphertext) {
            defer wg.Done()
            if err := f(ct); err != nil {
                errChan <- err
            }
        }(cts[i])
    }

    wg.Wait()
    close(errChan)

    if err := <-errChan; err != nil {
        return err
    }
    return nil
}

// Lattice automatically uses SIMD when available
// Check CPU features
import "golang.org/x/sys/cpu"

if cpu.X86.HasAVX512 {
    // AVX-512: 16x speedup for modular arithmetic
} else if cpu.X86.HasAVX2 {
    // AVX2: 8x speedup
} else if cpu.X86.HasSSE42 {
    // SSE4.2: 4x speedup
}

import "runtime/pprof"

// Start CPU profiling
f, _ := os.Create("cpu.prof")
pprof.StartCPUProfile(f)
defer pprof.StopCPUProfile()

// Run your computation
// ...

// Analyze with: go tool pprof cpu.prof

// Memory profiling
f, _ := os.Create("mem.prof")
defer f.Close()
runtime.GC()
pprof.WriteHeapProfile(f)

// Analyze with: go tool pprof mem.prof

// Efficient serialization
func SerializeCiphertext(ct *Ciphertext) ([]byte, error) {
    var buf bytes.Buffer
    enc := gob.NewEncoder(&buf)

    // Use compression for network transfer
    zw := gzip.NewWriter(&buf)
    enc = gob.NewEncoder(zw)

    if err := enc.Encode(ct); err != nil {
        return nil, err
    }

    zw.Close()
    return buf.Bytes(), nil
}

// Minimize data transfer in multiparty protocols
type CompressedShare struct {
    Data []byte
    Hash [32]byte
}

func CompressShare(share *Share) (*CompressedShare, error) {
    // Serialize
    data, err := share.MarshalBinary()
    if err != nil {
        return nil, err
    }

    // Compress
    var buf bytes.Buffer
    zw, _ := zlib.NewWriterLevel(&buf, zlib.BestCompression)
    zw.Write(data)
    zw.Close()

    // Hash for integrity
    hash := sha256.Sum256(buf.Bytes())

    return &CompressedShare{
        Data: buf.Bytes(),
        Hash: hash,
    }, nil
}

// Optimize modulus chain for your computation depth
func OptimizeModulusChain(multDepth int, rescaleFreq int) []int {
    // Each multiplication consumes ~60 bits
    // Each rescale removes one prime

    chainLength := multDepth + rescaleFreq
    logQ := make([]int, chainLength+1)

    // First prime: larger for initial noise
    logQ[0] = 60

    // Middle primes: standard size
    for i := 1; i < chainLength; i++ {
        logQ[i] = 50
    }

    // Last prime: smaller acceptable
    logQ[chainLength] = 40

    return logQ
}

// Start with minimal parameters and increase as needed
params := ckks.ParametersLiteral{
    LogN: 13, // Start small
    LogQ: []int{45, 40, 40}, // Minimal chain
    LogP: []int{55}, // Single P prime
}

// Increase only if needed for:
// - Security: Increase LogN
// - Precision: Increase LogQ values
// - Depth: Add more LogQ primes

// Batch multiple operations into single ciphertext
values := make([]complex128, params.Slots())
for i := range values {
    values[i] = complex(data[i], 0)
}
encoder.Encode(values, plaintext)
// Process all slots simultaneously

// Delay expensive operations
type LazyComputation struct {
    ct     *Ciphertext
    ops    []func(*Ciphertext) error
}

func (lc *LazyComputation) Add(op func(*Ciphertext) error) {
    lc.ops = append(lc.ops, op)
}

func (lc *LazyComputation) Execute() error {
    for _, op := range lc.ops {
        if err := op(lc.ct); err != nil {
            return err
        }
    }
    return nil
}

// Cache frequently used computations
var cache = make(map[string]*Ciphertext)
var cacheMu sync.RWMutex

func GetOrCompute(key string, compute func() *Ciphertext) *Ciphertext {
    cacheMu.RLock()
    if ct, ok := cache[key]; ok {
        cacheMu.RUnlock()
        return ct
    }
    cacheMu.RUnlock()

    ct := compute()

    cacheMu.Lock()
    cache[key] = ct
    cacheMu.Unlock()

    return ct
}