opendp 0.14.2-dev.20260401.2

A library of differential privacy algorithms for the statistical analysis of sensitive private data.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

use dashu::rational::RBig;

use crate::{
    domains::AtomDomain,
    metrics::AbsoluteDistance,
    traits::{SaturatingCast, samplers::sample_discrete_laplace},
};

use super::*;

fn make_test_scorer()
-> Fallible<Measurement<AtomDomain<u32>, AbsoluteDistance<u32>, MaxDivergence, (f64, &'static str)>>
{
    Measurement::new(
        AtomDomain::<u32>::default(),
        AbsoluteDistance::<u32>::default(),
        MaxDivergence,
        Function::new_fallible(|arg| {
            let noise = u32::saturating_cast(sample_discrete_laplace(RBig::ONE)?);
            Ok(((*arg + noise) as f64, "arbitrarily typed candidate info"))
        }),
        PrivacyMap::new(|d_in| *d_in as f64),
    )
}

#[test]
fn test_make_select_private_candidate_without_max_iters() -> Fallible<()> {
    let m_score = make_test_scorer()?;
    let threshold = 12.0;
    let stop_probability = 0.01;
    let m_select = make_select_private_candidate(m_score, stop_probability, threshold)?;
    (0..10).try_for_each(|_| match m_select.invoke(&10)? {
        Some((score, _)) if score < threshold => fallible!(
            FailedFunction,
            "returned score must never be below threshold"
        ),
        _ => Ok(()),
    })?;

    // This constant comes from:
    // 2 * m_score.map(d_in) + 0
    // 2 * 1
    assert_eq!(m_select.map(&1)?, 2.0);
    Ok(())
}

fn make_nan_test_scorer()
-> Fallible<Measurement<AtomDomain<u32>, AbsoluteDistance<u32>, MaxDivergence, (f64, &'static str)>>
{
    Measurement::new(
        AtomDomain::<u32>::default(),
        AbsoluteDistance::<u32>::default(),
        MaxDivergence,
        Function::new_fallible(|_| Ok((f64::NAN, "arbitrarily typed candidate info"))),
        PrivacyMap::new(|d_in| *d_in as f64),
    )
}

#[test]
fn test_make_select_private_candidate_with_nan() -> Fallible<()> {
    let m_score = make_nan_test_scorer()?;
    let threshold = 12.0;
    let stop_probability = 0.01;
    let m_select = make_select_private_candidate(m_score, stop_probability, threshold)?;
    (0..10).try_for_each(|_| match m_select.invoke(&10)? {
        Some((score, _)) if score < threshold => fallible!(
            FailedFunction,
            "returned score must never be below threshold"
        ),
        _ => Ok(()),
    })?;

    // This constant comes from:
    // 2 * m_score.map(d_in)
    // 2 * 1
    assert_eq!(m_select.map(&1)?, 2.0);
    Ok(())
}