differential-privacy-mechanisms

Differential Privacy Mechanisms Skill Guide

This skill governs the mathematical formulation and machine learning implementation of ((\epsilon, \delta))-differential privacy to guarantee statistical anonymity.

---

1. Mathematical Fundamentals & Noise Perturbation

A randomized algorithm $\mathcal{M}$ satisfies $(\epsilon, \delta)$-differential privacy if for all neighboring datasets $D, D'$ differing by at most one individual record, and for all query outputs $S \subseteq \text{Range}(\mathcal{M})$:

$$\mathbb{P}[\mathcal{M}(D) \in S] \le e^{\epsilon} \cdot \mathbb{P}[\mathcal{M}(D') \in S] + \delta$$

[ True Query Result / Gradient ] (Sensitivity = Delta f)
                 |
                 +---> Add Calibrated Noise
                         |-- Laplace Noise: Lap(scale = Delta f / epsilon)  [Pure epsilon-DP]
                         |-- Gaussian Noise: N(0, sigma^2) where            [(epsilon, delta)-DP]
                         |   sigma = sqrt(2 * ln(1.25 / delta)) * Delta f / epsilon
                 |
                 v
[ Private Sanitized Output (Mathematically bounded re-identification risk) ]

---

2. Production Code Implementations

A. Calibrated Laplace & Gaussian Query Perturbation (Python)

import numpy as np


class DPQueryEngine:
    def __init__(self, epsilon: float, delta: float = 1e-5):
        if epsilon <= 0:
            raise ValueError("Epsilon must be strictly positive")
        self.epsilon = epsilon
        self.delta = delta

    def private_count(self, true_count: int) -> int:
        """Counts have an L1 sensitivity of exactly 1."""
        scale = 1.0 / self.epsilon
        noise = np.random.laplace(0, scale)
        return max(0, int(round(true_count + noise)))

    def private_mean(self, values: list[float], lower_bound: float, upper_bound: float) -> float:
        """Clips values to [lower_bound, upper_bound] to enforce bounded sensitivity."""
        n = len(values)
        if n == 0:
            return 0.0

        clipped = np.clip(values, lower_bound, upper_bound)
        sum_sensitivity = upper_bound - lower_bound

        # Gaussian Mechanism for bounded sum
        sigma = np.sqrt(2 * np.log(1.25 / self.delta)) * sum_sensitivity / self.epsilon
        noisy_sum = np.sum(clipped) + np.random.normal(0, sigma)

        return float(noisy_sum / n)