{'fraction_non_alphanumeric': 0.04003394247961936, 'fraction_numerical': 0.0073036942752371424, 'mean_word_length': 4.501500500166722, 'pattern_counts': {'":': 0, '<': 2, '<?xml version=': 0, '>': 1, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 2, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Information, Privacy and Stability in Adaptive Data Analysis

Traditional statistical theory assumes that the analysis to be performed on a given data set is selected independently of the data themselves. This assumption breaks downs when data are re-used across analyses and the analysis to be performed at a given stage depends on the results of earlier stages. Such dependency can arise when the same data are used by several scientific studies, or when a single analysis consists of multiple stages. How can we draw statistically valid conclusions when data are re-used? This is the focus of a recent and active line of work. At a high level, these results show that limiting the information revealed by earlier stages of analysis controls the bias introduced in later stages by adaptivity. Here we review some known results in this area and highlight the role of information-theoretic concepts, notably several one-shot notions of mutual information.


Introduction
How can one do meaningful statistical inference and machine learning when data are re-used across analyses? The situation is common in empirical science, especially as data sets get bigger and more complex. For example, analysts often clean the data and perform various exploratory analysesvisualizations, computing descriptive statistics-before selecting how data will be treated. Many times the main analysis also proceeds in stages, with some sort of feature selection followed by inference using the selected features. In such settings, the analyses performed in later stages are chosen adaptively based on the results of earlier stages that used the same data. Adaptivity comes into even sharper relief when data are shared across multiple studies, and the choice of the research question in subsequent studies may depend on the outcomes of earlier ones. Adaptivity has been singled out as the cause of a "statistical crisis" in science [27].
There is a large body of work in statistics and machine learning on preventing false discovery, for example by accounting for multiple hypothesis testing. Classical theory, however, assumes that the analysis is fixed independently of the data-it breaks down completely when analyses are selected adaptively. Natural techniques, such as separating a validation set ("holdout") from the main data set to verify conclusions or the bootstrap method, do not circumvent the issue of adaptivity: once the holdout has been used, any further hypotheses tested using the same holdout will again depend on earlier results. Blum and Hardt [8] point out that this issue arises with leaderboards for machine learning competitions: they observe that one can do well on the leaderboard simply by using the feedback provided by the leaderboard itself on an adaptively selected sequence of submissions-that is, without even consulting the training data! To formalize our situation somewhat, imagine there is a population that we wish to study, modeled by a probability distribution P. An analyst selects a sequence of analyses M 1 , M 2 , ..., that she wishes to perform (we specify the type of analysis to consider later). In an ideal world ( Figure  1, left), the analyst would run each analysis M i on a fresh sample X (i) from the population. For simplicity, we only discuss i.i.d samples in this article; we may assume that each sample X (i) has n points, drawn independently from P. In the real (adaptive) setting, the same data set X gets used for each analysis (Figure 1, right). The challenge is that we ultimately want to learn about P, not X, but adaptive queries can quickly overfit to X.
Our goal is to relate these two settings-to develop techniques that allow us to emulate the ideal world in the real one, and understand how much accuracy is lost due to adaptivity. As mentioned above, merely setting aside a holdout to verify results at each stage is not sufficient, since the holdout ends up being re-used adaptively. If the number k of analyses is known ahead of time, one can split the data into k pieces of n/k points each (assuming i.i.d. data, the pieces are independent). This practice, called data splitting, provides clear validity guarantees, but is inefficient in its use of data: data splitting requires n to be substantially larger than k, while we will see techniques that do substantially better. Data splitting also requires an agreed upon partition of the data, which can be problematic with data shared across studies.
A line of work in computer science [21,28,20,19,40,41,6,39,46,23,24] initiated by Dwork, Feldman, Hardt, Pitassi, Reingold, and Roth [21] and Hardt and Ullman [28] provides a set of tools and specific methodology for this problem. This article briefly surveys the ideas in these works, with emphasis on the role of several information-theoretic concepts. Broadly, there is a strong connection between the extent to which an adaptive sequence of analyses remains faithful to the underlying population P, and the amount of information that is leaked to the analyst about X. In particular, randomization plays a key role in the state of the art methods, with a notion of  Figure 1: Ideally, we would collecty fresh data from the same population P for each analysis (left). In many real settings, we have only a single data set that must be re-used, leading to adaptively selecected analyses (right). The arrows pointing into the top of the analyses indicate that each analysis is selected based on the results of previous stages.
algorithmic stability-differential privacy-playing a central role.
Another approach, with roots in the statistics community, seeks to model particular sequences of analyses, designing methodology to adjust for the bias due to conditioning on earlier results (e.g., [36,30,26,22,34,32]). The specificity of this line of work makes it hard to compare with the more general approaches from computer science. Other work in statistics hews an intermediate path, allowing the analyst freedom within a prespecified class of analyses [7,10]. There are intriguing similarities between these lines of work and the work surveyed here, such as the use of randomization to break up dependencies (e.g., [42,43,29]); understanding these connections more deeply is an important direction for future work.

The Lessons of Linear Queries
A simple but important setting for thinking about adaptivity, introduced by Dwork et al. [21] and Hardt and Ullman [28], is that of an analyst posing an adaptively selected sequence of queries, each of which asks for the expectation of a bounded function in the population. Such queries capture a wide range of basic descriptive statistics (the prevalence of a disease in a population, for example, or the average age). Many inference algorithms can also be expressed in terms of a sequence of such queries [31]; for example, optimization algorithms that query the gradient of a Lipschitz, decomposable loss function.
Suppose each data point lies in a universe X , so that a data set lies in X n and the underlying population is a distribution on X . A bounded linear query is specified by a function φ : X → [0, 1]. The population value of a linear query is simply the expected value of the function when evaluated on an element of the data universe drawn according to P, denoted φ(P) = E x∼P [φ(x)]. 1 Consider now an interaction between an analyst wishing to pose such queries and an algorithm M (called the mechanism) holding a data set X sample i.i.d from P that attempts to provide Figure 2: Adaptively selected linear queries approximate answers to the queries φ 1 , φ 2 , .... This is illustrated in Figure 2, where we use subscripts (as in M 1 , M 2 , ...) to distinguish k different rounds of M . In general, neither the mechanism nor the analyst knows the exact distribution P (otherwise, why collect data?), so the mechanism cannot always answer φ(P). A natural approach is to answer with the empirical mean φ(X) = 1 n x i ∈x φ(X i ). When queries are selected nonadaptively, this is the best estimator of φ(P). We shall see, however, this is not the best mechanism for estimating the expectations of adaptively selected queries! Given a query answering mechanism M , a data analyst A, and a distribution P on the data universe X , consider a random interaction defined by selecting a sample X of n i.i.d. draws from P, and then having A interact with M (X) for k rounds, where in each round i, (i) A selects φ i (based on a 1 , . . . , a i−1 ), (ii) M answers a i . The (population) error of M is the random variable

Adaptive Linear Queries
which depends on X as well as the coins of M and A. Definition 1. A query answering mechanism M is (α, β)-accurate on i.i.d. data for k queries if for every data analyst A and distribution P, we have The probability is over the choice of the dataset X ∼ i.i.d. P and the randomness of the mechanism and the analyst. Similarly, the expected error of M is the supremum, over distributions P and data analysts A, of E(err X (M, A)) . We sometimes fix the distribution P and take the supremum only over analysts A.
It is important to note that this definition makes no assumptions on how the analyst selects queries, except that the selection is based on the outputs of M and not directly on the data. The aim of this line of work is to design mechanisms with provable bounds on accuracy. We aim for mechanisms that are universal, in the sense that they can be used in any type of exploratory or adaptive workflow.

Failures of Straightforward Approaches
As mentioned above, there are a couple of natural approaches to this problem. The first is to answer queries using each query's empirical mean φ(x). When queries are specified nonadaptively, a standard argument shows that the population error of that strategy is Θ (log k)/n . In contrast, in the adaptive setting, the empirical mechanism's error may be unbounded even with just two queries. For example, the query φ may be selected such that the low-order bits of φ 1 (x) reveal all the entries of the data set x. In that case, the analyst may construct a query φ 2 which takes the value 1 for values in the data set x, and 0 otherwise. The empirical mean φ 2 (x) will be 1, while the population mean φ 2 (P) will be close to 0 for any distribution P with sufficiently high entropy.
This last example seems contrived, since it requires seemingly atypical structure from the initial query φ 1 . For example, constraining the queries φ to be predicates taking values in {0, 1} seems to eliminate the problem. However, the example is instructive for at least two reasons. First, it illustrates the role that information about the data set can play: learning x allows the analyst to pose a query that is highly overfit to the data set, and thus difficult for the mechanism to answer accurately. Conversely, we will see that limiting the information revealed about the data strongly limits overfitting.
Second, when the analyst asks more queries, one can construct much more natural examples of analyses that go awry when using the empirical mean. For instance, consider a data set where each individual data point lies in X = {0, 1} k−1 × {0, 1}, where we think of the first k − 1 bits as a vector of binary features, and the last bit as a label. Consider a particular analyst (from [20]) aiming to find a good classification rule for the label. The analyst's first k − 1 queries ask for the success rate of each of the k − 1 features in predicting the label. In the k-th query, the analyst constructs a classifier that takes a majority vote among those features that had success rate greater than 50%. On uniformly random data (where the label is independent of the features), the mechanism will report the success rate of this last classifier to be 55% when k = n 10 , and 67% when k = n (even though its success rate on the population would be 1/2). Generalizing the example somewhat, one can show that even with very simple data distributions, the error of empirical mechanism scales as Θ( k/n)-exponentially larger than the error one gets with nonadaptively specified queries. Encapsulating this discussion, we have: Proposition 1. When answering k nonadaptively specified queries, the empirical mechanism has expected error Θ log(k)/n . When answering k adaptively selected queries, the empirical mechanism has expected error Ω k/n , even for predicate queries on uniformly random data in {0, 1} k .
Data Splitting Another natural approach for handling adaptively specified queries is data splitting: when k is known in advance, one may divide the data set into k subsamples of n/k points each, and answer the i-th query using its empirical mean on the i-th data set. This approach means that we can truly ignore adaptivity and use all the tools of classical statistics; the downside is that we are limited to the accuracy one can get with sample size n/k. The fact that we want a bound that is uniform over all k queries adds a further logarithmic factor to the final error bound: Proposition 2. When answering k adaptively specified queries, the data splitting mechanism has expected error Θ( k(log k)/n).
For both of these natural mechanisms, answering queries with error α, even with constant probability, requires n to grow at least as fast as k/α 2 . Can we do better? How good a dependency on α and k is possible?

A Sample of Known Bounds
In fact, there are mechanisms that can answer a sequence of k adaptively selected linear queries with much higher accuracy than that provided by the straightforward approaches. Namely, for a given accuracy α, we can get mechanisms that work for n that scales only as √ k/α 2 -a quadratic improvement in k. The bounds below are stated in terms of expected error for simplicity; the underlying arguments also provide high-probability bounds on the tail of this error.
Theorem 3 ( [21,6]). There is a computationally efficient mechanism for k statistical queries with expected A simple mechanism that achieves this bound is one that adds Gaussian noise with standard deviation about 4 √ k/ √ n to each query. One can give a different-looking mechanism-which we do not describe in this survey-to automatically adjust to the actual "amount" of adaptivity in a given sequence of queries. Specifically, imagine that the k queries are grouped into r batches, where the queries in a given batch depend on answers to queries in previous batches but not on the answers to queries in the same batch. For example, in the classification example of the previous section, the number of rounds r is only 2.

Theorem 4 ([21]
). If there are at most r rounds of adaptivity, then there is a computationally efficient mechanism with expected error O r(log k)/n . The algorithm is not given the partition of the queries into batches.
The ideas underlying the two previous algorithms can also be adapted to give better results when we make further assumptions about the class of allowed queries, or the universe from which the data are drawn. One such result, due to Dwork et al. [21] (and tightened in [6]), recovers a logarithmic dependence on k in exchange for a dependence on the size of the universe X in which the data lie.
Theorem 5 ( [21,6]). There is a computationally inefficient mechanism with expected error O 6 log |X | 3 (log k)/n . The mechanism runs in time linear in |X | (and not log |X | as one would naturally want).
None of these upper bounds is known to be tight in all parameter regimes, but some lower bounds are known, in particular showing that the scaling n = Ω( √ k) cannot be improved, and that inefficiency of the mechanism in Theorem 5 is necessary.
Theorem 6 (Hardt and Ullman [28], Steinke and Ullman [41]). For every mechanism M that answers k adaptively selected linear queries, for a sufficiently large universe X (with log |X | exponential in n), there exist a distribution P and an analyst A for which the mechanism's error err X (M, A) is Ω √ k/n with constant probability. Furthermore, for mechanisms that answer faithfully with respect to both the distribution and the data set (that is, they provide answers close to both φ i (X) and φ i (P)), the bound can be strengthened to Ω 4 √ k/ √ n Finally, if we assume that one-way functions exist, then the bounds continue to hold when log |X | has polynomial size, for polynomial-time mechanisms (but not for those that can take exponential time).
We won't discuss the proof of these lower bounds here, but we note that closing the gap between the upper and lower bounds remains an intriguing open problem.

Privacy and Distributional Stability
The upper bounds above are obtained via a connection between adaptive analysis and certain notions of algorithmic stability. Broadly, algorithmic stability properties limit how much the output of an algorithm can change when one of its inputs is changed. Different notions of stability correspond, roughly, to different measures of distance between outputs. There is a long-standing connection between algorithmic stability and expected generalization error (e.g., Devroye and Wagner [14], Bousquet and Elisseeff [9]). Essentially, stable algorithms cannot overfit. It seems that if we could design adaptive query-answering mechanisms that are stable in an appropriate sense, we could get validity guarantees for adaptive data analysis.
Alas, there is a hitch. Recall that our goal is to design mechanisms that provide statistically valid answers no matter how the analyst selects queries. Even if each stage of the mechanism is stable, the overall process might not be-in an adaptive setting, the analyst ends up being part of the mechanism.
The resolution is to consider a distributional notion of stability. We will require that changing any single data point in x have a small effect on the distribution of the mechanism's outputs. If we choose a distance measure on distributions that is nonincreasing under postprocessing, then we can limit the effect of the analyst's choices.
Specifically, we work with "differential privacy", a notion of stability introduced in the context of privacy of statistical data. Differential privacy seeks to limit the information revealed about any single individual in the data set.
Definition 2 ( [17,16]). An algorithm M : X n → O is ( , δ)-differentially private if for all pairs of neighboring data sets x, x ∈ X n , and for all events S ⊆ O: Differential privacy makes sense even for interactive mechanisms that involve communication with an outside party: we simply think of the outside party as part of the mechanism, and define the final output of the mechanism to be the complete transcript of the communication between the mechanism and the other party.
Differential privacy is a useful design tool in the context of adaptive data analysis because it is possible to design interactive differentially private algorithms modularly, due to two related properties: closure under postprocessing, and composition:  Taken together, these two properties mean that in order to design differentially private algorithms for answering linear queries, it is sufficient to make sure the mechanism run at each stage is differentially private.
Perhaps even more importantly, in order to ensure statistical validity-that is, accuracy with respect to the underlying population-it suffices to design differentially private algorithms that are accurate with respect to the sample x: Theorem 9 (Main Transfer Theorem [21,6]). Suppose a statistical estimator M is ( , ·δ)-accurate with respect to its sample, that is, for all data sets x, If M is also ( , · δ)-differentially private, then it is (O( ), O(δ))-accurate with respect to the population (Definition 1).
This theorem underlies all two of the three upper bounds of the previous section (Theorems 3 and 5). Each is derived by using existing differentially private algorithms together with Theorem 9. For Theorem 4, Dwork et al. [21] used a different argument, based on compressing the output of the algorithm to a small set of possibilities; see Section 3.

A Two-stage Game, Stability and "Lifting"
We conclude this section with an outline of the proof of the main transfer theorem (Theorem 9). That theorem talks about analyses with many stages of interaction, but it turns out that the core of the argument lies in understanding a seemingly much simpler, two-stage process.
Consider a two-stage setting in which an analysis M is run on data set x, and the analyst selects a linear query φ : X → [0, 1] based on M (x) (Figure 3). We say M robustly (α, β)-generalizes if for all distributions P over the domain X , for all strategies (functions) A employed by the analyst, with probability at least 1 − β over the choice of X ∼ P n and the coins of M , we have that |φ(X) − φ(P)| ≤ α where φ = A(M (X)). (Similarly, we may talk about the expected generalization error, that is, the maximum over A and P of E(|φ(X) − φ(P)|).) The quantification over all selection functions A here is critical-when the first phase of analysis satisfies the definition, then a query asked in the following round cannot overfit to the data (except with low probability), no matter how it is selected.
Differential privacy (and a few other distributional notions of stability, such as KL-stability [6,47]) limits the adversary's score in this game. This connection had been understood for some timefor example, McSherry observed that it could be used to break up dependencies in a clustering "Monitor Argument" [BNSSSU'16] • Stronger bounds • Generalizes beyond "statistical queries" Figure 4: The "monitor" argument for lifting results about a two-stage game to many stages algorithm, and Bassily, Smith, and Thakurta [5] used a weak version of the connection to bound the population risk of differentially private empirical risk minimization.
However, the application to adaptive data analysis-and especially the understanding of the importance of post-processing to the design of universal mechanisms-came recently, in [21]. Their initial result was subsequently sharpened, to obtain the following tight connection: Theorem 10 (Differentially Private Algorithms Cannot Overfit [6]). If M is ( , δ)-differentially private, then it is (O( ), O(δ))-robustly generalizing.
Lifting to Many Stages Bounds on the two-stage game can be "lifted" to provide bounds on the k-phase game either through a sequential application of the bound to each round [21] or through a more holistic argument, called the monitor technique [6], that yields Theorem 9 (and Theorems 3 and 5).
The monitor argument is a thought experiment-we argue that for any multi-stage process, there is a two-stage process in which the error on the population equals the maximum population error over all k stages of the original process. The argument applies quite generally, but it is a bit simpler to explain under the assumption that the mechanism answers queries accurately with respect to the data set X. The idea, given an interaction between an analyst and adaptively selected mechanisms M 1 , M 2 , ..., M k , is to encapsulate the analyst and mechanisms into a single fictional entity M which gets, as additional input, the underlying distribution P. The fictional M executes an interaction and then outputs a single query φ * -the one which maximizes the population error over all stages i.
Beyond linear queries The techniques described in this section extend to problems that are not described by estimating the mean of a bounded linear functional. One important class is minimizing a decomposable loss function where each individual contributes a bounded term to the loss function [6].
A re-usable holdout The techniques described in this section can appear somewhat onerous for the analyst, since they require accessing data via differentially private algorithms. As pointed out by Dwork et al. [20], however, one need not limit access to the entire data set in this way. In fact, a more pragmatic approach is to give most of the data "in the clear" to the analyst, and protect only a small holdout set via the techniques discussed here. This still allows one to verify conclusions soundly, but additionally allows full exploratory analysis, as well as repeated verification ("holdout re-use").

The Intrigue of Information Measures
Despite the generality of the approach of the previous section, many important classes of analyses are not obviously amenable to those techniques; in particular, problems that are not easily stated in terms of a numerical estimation task.
Consider the problem of hypothesis testing. Crudely, given a set of distributions H (called the null hypothesis), we ask if the data set is "unlikely to have been generated" by a distribution P ∈ H. More precisely, we select an event T (the acceptance region) such that Pr X∼P n (X ∈ T ) is at most a threshold γ (often 0.05) for all distributions in H. If it happens that the observed data X lie outside of T , the null hypothesis is said to be rejected. If this happens when the true distribution P is actually in H, then we say a false discovery occurs. Hypothesis tests play a central role in modern empirical science (for better or for worse), and techniques to control false discovery in the classic, nonadaptive setting are the focus of intense study. Despite this, very little is known about hypothesis tests in adaptive settings.
Adaptivity arises when the event T is selected based on earlier analysis of the same dataconditioned on those earlier results Y = M (X), the probability that the test rejects the null hpyothesis given X might be much higher than γ even if P lies in H.
How much higher it can be depends on M and-as we will see-on several measures of the information leaked by M . To formalize this, consider a game similar to the overfitting game, in which the analyst A, given Y = M (X), selects an arbitrary event T Y = A(Y ) (which depends on Y ). For a particular output y of M , the analyst's "score" is score P,M,A,γ (y) = Pr X∼P n (X ∈ T y |Y = y) if Pr X∼P n (X ∈ T y ) ≤ γ , 0 if Pr X∼P n (X ∈ T y ) > γ .
Now consider the analyst's expected score in this game: η P,M,A (γ) = E Y score P,M,A (y) . As we will see below, the analyst's score in this game can be bounded using various definitions of the information leaked about X by Y . This score also plays a key role in controlling false discovery: Proposition 11. Bounding the score η has several important implications: is used by A to select a hypothesis test with significance γ, then the probability of false discovery is at most η P,M,A (γ). [19]

(Robust generalization
We are interested in universal bounds that hold no matter how the analyst uses the output Y , and no matter the original input distribution. To this end, we define η M (γ) = sup P,A (η P,M,A (γ)) .

Information and Conditioning
The function η M measures how much probabilities less than γ can be amplified by conditioning on Y , on average over values of Y .
For several one-shot notions of mutual information, we have that if a procedure leaks k "bits" of information we have η P,M,A (γ) ≈ γ · 2 k . Unfortunately, such a clean relationship is not known for the standard notion of Shannon mutual information. Instead, we consider two other notions here.
Fix two random variables X, Y with joint distribution given by p XY (x, y) = Pr(X = x, Y = y) and marginals p X (·) and p Y (·). Consider the information loss The standard notion of mutual information is the expectation of this variable: I(X; Y ) = E (I X,Y ). The max-information [12,19] between X and Y is the supremum of this variable. Unfortunately, for many interesting procedures, the max-information is either unbounded or much larger than the mutual information.
One can get a more flexible notion by instead considering a high-probability bound on the information loss: we say the β-approximate max information between X and Y is at most k 3 4 For many algorithms of interest, the approximate max-information turns out to be very close to the mutual information but, by providing a bound on the upper tail of I X,Y , allows for more precise control of small-probability events.
We can also define a related quantity, which we call the expected log-distortion: This notion of information leakage is not symmetric in X, Y . It is closely related to, but in general different from, the min-entropy leakage H ∞ (Y |X) − H ∞ (X) [15,1,25,2,3]. Of these notions, expected log distortion is the strongest since it upper bounds the other two: I(X; Y ) ≤ L ∞ (X; Y ) and I β ∞ (X; Y ) ≤ L ∞ (X; Y ) + log(1/β).
We know much weaker implications based only on bounding the mutual information. Most significantly, the bounds for general hypothesis testing are exponentially weaker than those one gets from the one-shot measures above.

What procedures have bounded one-shot information measures?
The information-theoretic framework of the previous subsection captures several other classes of algorithms that satisfy robust generalization guarantees. In addition to unifying the previous work, this approach shows that these classes of algorithms allow for principled post-selection hypothesis testing.
The most important of these, currently, is for the class of differentially private algorithms: Theorem 14 (Informal, see [39]). If M is ( , δ)-differentially private, and the entries of X are independent, then I β ∞ (X; M (X)) = O( 2 n) for β = O(n δ/ ).
This result, together with Theorem 12, implies that differentially-private algorithms are (O( ), O(n δ/ )robustly generalizing for data drawn i.i.d from any distribution P. It essentially recovers the results of the previous section on linear queries (with a worse value of β), but additionally applies to more general problems such as hypothesis testing.
Description length [19] In many cases, the outcome of a statistical analysis can be compressed to relatively few bits-for example, when the outcome is a small set of selected features. If the output of M can be compressed to k bits, then the expected log-distortion L ∞ (X; M (X)) is at most k bits. An argument along these lines was used implicitly in [21] to prove Theorem 4.
Compression Schemes Another important class of statistical analyses that have good (and robust) generalization properties are compression learners [33]. These process a data set of n points to obtain a carefully selected subset of only k << n points, and finally produce an output fit to those points. A classic example is support vector machines: in d dimensions, the final classifier is determined by just d + 1 points in the data set.
Cummings, Ligett, Nissim, Roth, and Wu [13] used classic generalization results for such learners to show that they satisfy robust generalization guarantees. The classic results as well as those of Cummings et al. [13] can be rederived from the following lemma (new, as far as we know) bounding the information leaked by a compression scheme about those points that are not output by the scheme.
Lemma 15 (Compression schemes). Let M : X n → X k be any algorithm that takes a data set x of n points and outputs a subset x out = M (x) of k points from x. Let x in ∈ X n−k denote the remaining data points, so that x in ∪ x out = x (as multisets). For any distribution P on X , if X ∼ P n , then L ∞ (X in ; X out ) ≤ log 2 n k .
Cummings et al. [13] used the robust generalization properties of compression learners to give robustly generalizing algorithms for learning any PAC-learnable concept class. In particular, this implies robustly generalizing algorithms for tasks that do not have differentially private algorithms, such as learning a threshold classifier with data from the real line.

Notes and Acknowledgments
I am grateful to many colleagues for introducing me to this topic and insightful discussions. Among others, my thanks go to Raef Bassily, Cynthia Dwork, Moritz Hardt, Kobbi Nissim, Ryan Rogers, Aaron Roth, Thomas Steinke, Uri Stemmer, Om Thakkar, Jon Ullman, Yu-Xiang Wang. Paul Medvedev provided helpful comments on the writing, making the survey a tiny bit more accessible to nonexperts. Finally, I thank Michael Langberg, this newsletter's editor, for soliciting this article and graciously tolerating delays in its preparation.
Although I tried to cover the main ideas in a recent line of work, that line is now diverse enough that I could not encapsulate everything here. Notable omissions include the "jointly Gaussian" models of Russo and Zou [40] and Wang et al. [46], which assume that the analyst is selecting among a family of statistics that are jointly normally distributed under P , work of Elder [23,24] on a Bayesian framework that encodes a further restriction that the mechanism "know as much" as the analyst about the underlying distribution P, and the "typcial stability" framework [4,13]. There are no doubt other contributions that I lost in my effort to consolidate. Some ideas in this survey, notably the information-theoretic viewpoint on compression-based learning, have not appeared elsewhere; they have not been peer-reviewed.