Property testing [31,15] aims to lay algorithmic foundations for processing big data. It is a formal study of fast algorithms that accept objects with a given property and reject objects that are far. The goal of this work is to compare models of property testing that address the situations when the data that needs to be analyzed is not only large, but also incomplete or noisy. The models we consider allow for adversarial manipulation of the input, but differ in whether the manipulation can be done only offline, i.e., before the execution of the algorithm, or online, i.e., as the algorithm runs. The manipulations by an adversary can come in the form of erasures or corruptions. The offline erasure-resilient property testing model was proposed by Dixit et al. [9]. The model that captures offline corruptions is called tolerant testing and was introduced by Parnas et al. [25]. The online analogues of these models were recently defined by Kalemaj et al. [21].
We compare the query complexity and the randomness complexity of property testing in the offline and online models. In the offline-erasure model, a constant fraction of the input is erased adversarially before the execution of the algorithm, whereas in the online-erasure model, the adversary is allowed to make a fixed number of erasures after each query. It may seem that the online adversary has strictly more power, and thus testing in the online models should require more queries. Indeed, [21] justify this intuition and show that simple properties -sortedness and the Lipschitz property of sequences -cannot be tested at all with online erasuresfoot_0 , even though they are testable using a small number of queries when erasures are offline. Intuitively, [21] show that testing in the presence of one online erasure per query (performed by an adversary with the knowledge of previous queries) can be harder than testing when a constant fraction of the input is adversarially erased offline (in advance). The following natural open question is stated in [21]: "Is there a property that has smaller query complexity in the online-erasure-resilient model than in the (offline) erasure-resilient model of [9]?" We answer this question in the affirmative: specifically, we construct a property that can be tested with a constant number of queries in the online-erasure model (and even in the (harder) online-corruption model), but requires a nearly linear number of queries in the offline-erasure model. We conclude that the two adversarial erasure models are incomparable.
Our second result concerns the randomness complexity of testing in the online and offline manipulation models. Randomness is an important tool in the design of a wide variety of algorithms, and extensive research has been conducted to understand the power of randomness in computation. The investigation of the randomness complexity of property testing algorithms was initiated by Goldreich and Sheffet [18]. They showed that all property testers in the standard model can be derandomized to a large extent: they can be converted to testers that use the number of random bits that is logarithmic in the size of the input, while incurring at most a constant factor blowup in query complexity. The result of [18] easily extends to all offline testing models, but does not apply in the online setting. Moreover, the existing testers in the online model [21,24,6,33,3] use lots of randomness to fool the adversary. A natural question that arises is how much derandomization is possible in the online setting. We show that a lot of randomness is sometimes indeed necessary to test in the presence of an online adversary. In particular, we exhibit a property that requires exponentially more random bits to test in the online manipulation model than in the offline manipulation model. This result provides a natural converse to the statement of [24] that "the (online) adversary cannot foil our plan if there is no plan" -i.e., random queries are robust to online manipulation of the input.
We represent the input to our property testing algorithm as a string. The algorithm is given access to its input string via queries (specifically, of the form "what is the character at index i?"). For each proximity parameter ε ∈ (0, 1), the algorithm has to distinguish between strings that have a specified property and strings that are ε-far from having the propertyi.e., strings that need to be changed on at least an ε-fraction of indices in order to satisfy the property. The query complexity (the number of queries to the input) of the tester is measured in terms of ε and the input length n. In this section, for simplicity, ε is considered to be a constant and omitted from the statements.
We show that the online and offline adversarial models of property testing are incomparable in terms of the query complexity. Recall that [21] prove that sortedness and Lipschitzness of sequences are efficiently testable with offline erasures, but cannot be tested at all even with one online erasure per query 2 . We complement this result with the following theorems, which show that testing in the presence of a small fraction of offline erasures can be harder than testing with online erasures. The first of this theorems (Theorem 1.1) considers the regime with many online erasures per query; the second (Theorem 1.1) considers the regime with one erasure per query. The former exhibits a logarithmic gap in query complexity, where as the latter exhibits a nearly linear gap.
There exists a property that can be tested using a constant number of queries in the presence of an online adversary that makes O n log n erasures per query; but requires Ω(log n) queries 3 to test when the characters at Θ n log log n indices are erased offline (in advance).
We cannot expect to prove an analogue of Theorem 1.1 for the case when the number of online erasures per query is the same as the total number of offline erasures. This is because, after the first query, an online adversary can erase the same part of the input that the offline adversary would have erased in advance.
▶ Remark 1.2. Although the online erasure rate in Theorem 1.1 is very large, the total number of erasures available to the online adversary is smaller than the number of offline erasures we considered. It is an intriguing open question whether there exists a property for which every tester in the online model accumulates at least as many erasures as the best tester in the offline model, but also requires fewer queries to test in the online model than in the offline model.
At the other end of the spectrum, we show that if the number of erasures is much smaller in the online model than in the offline model, then there is an exponentially large gap -i.e., there are properties that can be tested with a constant number of queries when the erasures are online but require a nearly linear number of queries in the offline erasure model.
There exists a property that can be tested with a constant number of queries in the presence of an online adversary that makes one erasure per query, but requires Ω(n) queries to test when the characters at Θ n log n indices are erased offline (in advance). 2 We note that there is an even simpler property than sortedness and Lipschitzness of sequences that is easily testable with offline erasures or corruptions, but is not testable at all with online erasures. Moreover, this property is over the alphabet Σ = {0, 1}. Specifically, P = {ww : w ∈ {0, 1} * }. We can estimate the distance to this property within additive error ε using O( 1 ε 2 ) queries (and therefore it is easily tolerantly testable). However, we cannot test it with online erasures because, whenever the tester queries some position p in an input string of length 2n, the adversary can erase the corresponding position (n + p if p ≤ n and p -n if p > n). 3 The notation Ω(f (n)) hides polylog f (n) factors, e.g., Ω(log n) = Ω(log n/ polyloglog n).
In fact, the query complexity separations in Theorems 1.1 and 1.3 hold even if the online adversary can make corruptions instead of erasures.
To prove Theorems 1.1 and 1.3, we show that any property that separates the offline model from the standard one, i.e., a property that is easy to test in the standard model but hard in the offline model, can be "lifted" to separate the offline and online models. We can then leverage the state of the art separation (between the standard and offline-manipulation testing models) of [5] to obtain strong separations between the online and offline manipulation models.
Our "lifting" operation is simply encoding the property with a repetition code. Intuitively, repetition won't make the property easier to test in the presence of offline erasures since the same erasures can be made on all copies. Our main technical proof for this part is to show that repetition code is robust against online adversaries. We prove the following general result.
▶ Lemma 1.4 (Informal version of Lemma 3.5). If a property P is testable when no adversary is present then the repeated version P r , given by concatenating each string in P with itself r times, is testable in the presence of an online adversary (as long as the number of erasures per query is not too large).
As discussed earlier, the investigation of the randomness complexity of property testing algorithms was initiated by Goldreich and Sheffet [18] who showed that every property that is testable in the standard model using q queries can be tested using O(q) queries and O(log n) random bits. We build on their investigation by studying the randomness complexity of the erasure models. Though their result easily extends to the offline models, the same extension does not work in the online model. Indeed, we show that the derandomization of [18] cannot be extended to the online testing model -that is, we construct a property that requires ω(log n) random bits to test in the online model.
Note that a randomness separation trivially holds for properties which are not testable with online erasures, or when the offline-erasure-resilient tester is allowed to query the entire input 4 . Prior to our work it was not clear if there is a randomness separation that applies to properties that are testable in the online model, and still holds if we require that the testers in both models to have a sublinear (in n) query complexity.
We demonstrate such a separation. In particular, we show that there exists a property that is testable in both models using a sublinear number of queries, and, moreover, testing this property in the online erasure model requires exponentially more random bits than testing it in the offline erasure model.
There exists a property that can be tested using O( √ n) queries in the presence of either an online or an offline adversary. The tester against the offline adversary uses O(log n) random bits, whereas every tester in the presence of an online adversary that makes one erasure per query requires Ω( √ n) random bits to succeed with constant probability. Theorem 1.5 follows easily from a more general result, Theorem 4.1, which we prove in Section 4 and which yields meaningful separations for larger online erasure rates as well. The main technique we develop to prove a lower bound on the randomness complexity of testing with an online adversary is a transformation from randomness-efficient testers in the online model to query efficient testers in the standard model. A special case of the guarantees of our transformation is stated in Lemma 1.6. (The general version appears in Lemma 4.3.) To prove Theorem 4.1, we combine our transformation with existing results regarding the property of strings called τ -Distinct-Elements, which is parametrized by τ ∈ N, and consists of strings that have at most τ distinct characters. Testing τ -Distinct-Elements was recently investigated in [17,2,1,20], and it is a natural testing version of the distinct elements approximation problem studied in [28,32]. For a more detailed exposition regarding the history of the τ -Distinct-Elements property and its variants see [20].
▶ Lemma 1.6 (Special case of Lemma 4.3 for one online erasure per query). Fix r ∈ N. If a property P can be tested using r random bits in the presence of an online adversary that makes one erasure per query, then P can be tested in the standard model (with the same proximity parameter ε) using at most r queries.
The technique from Lemma 1.6, combined with the derandomization results of [18], immediately yields a separation for ε = o 1 log n : Consider the property P ⊆ {0, 1} n of being the zero string. By the folklore property testing bound, Θ( 1 ε ) queries are necessary and sufficient to test P. By [18], there exists a tester in the offline erasure model that uses O(log n) random bits. However, by Lemma 1.6, every tester in the online model must use Ω( 1ε ) = ω(log n) random bits. While this works for small ε, the separation we show in Theorem 1.5 (and the more general Theorem 4.1) holds for constant ε as well.
In terms of query complexity, testing with offline erasures lies between standard and tolerant testing. By definition, an offline-erasure-resilient tester is also a property tester in the standard model, because it has to work on the inputs with no erasures. Not surprisingly, offline testing with erasures is no harder than offline testing with corruptions. This is formalized in [9, Theorem 1.4] that shows that the existence of a tolerant tester for a property implies the existence of an offline-erasure-resilient tester for that property for a comparable setting of parameters. There are also separations that show that standard testing is strictly easier than offline-erasure-resilient testing, which in turn is strictly easier than tolerant testing. Specifically, Dixit et al. [9] showed that a property defined by Fischer and Fortnow [13] can be tested in the standard model with a constant number of queries, but requires n Ω (1) queries in the offline-erasure-resilient model. This separation was strengthened by Ben-Eliezer et al. [5], improving n Ω (1) to Ω(n). Finally, Raskhodnikova et al. [29] prove a separation similar to that of [9] between offline-erasure-resilient testing and tolerant testing. Thus, at a high level, we have a complete picture in terms of the relative difficulty of testing in the three offline models.
Kalemaj et al. [21] exhibit two properties of strings for which testing with online erasures is impossible for every proximity parameter ε ≤ 1 2 , whereas testing in the offline models is easy. The first property, sortedness, consists of sorted arrays, i.e., strings x of length n such that x i ≤ x i+1 for all i ∈ [n -1]. The query complexity of testing sortedness (for constant ε) is Θ(log n) in both the standard and the offline erasures model (when the erased part is at most a constant fraction of the input) [11,10,26,12,7,8,27,4,9]. The second property, Lipschitzness, consists of strings
) queries in both the standard and the offline models [19,9].
We start by stating standard property testing definitions. We represent an input to a property testing algorithm as a string of length n over some alphabet Σ n that might depend on n.
For example, Σ n might be {0, 1} or [n].
For a set S of strings of length n, define δ H (x, S) = min y∈S δ H (x, y). A property P is a subset of Σ * given by n∈N P n , where each P n consists of strings of length n over some alphabet
▶ Definition 2.2 (ε-tester in the standard model [31,15]). For every property P ⊆ Σ * and proximity parameter ε ∈ (0, 1), an algorithm T is an ε-tester for P if, given a parameter n ∈ N and oracle access to input x ∈ Σ n , the algorithm T accepts with probability at least 2 3 whenever x ∈ P and rejects with probability at least 2 3 whenever x is ε-far from P. A tester has a one-sided error if it always accepts inputs x ∈ P.
The offline model with erasures was introduced by [9] and subsequently studied in [30,29,5,23]. The definition we use here is adapted from [23] and only differs from the original definition in how the parameter ε is interpreted. We use ⊥ to denote an erased symbol in the input. ▶ Definition 2.3 (α-erased string, completion). For each α ∈ (0, 1), a string x ∈ (Σ ∪ {⊥}) n is α-erased if at most an α fraction of symbols in it are ⊥. The indices of the ⊥ symbols in the string are called erased. A string y ∈ Σ n that differs from a string x ∈ (Σ ∪ {⊥}) n only on indices erased in x is called a completion of x. ▶ Definition 2.4 (Offline-erasure-resilient tester [9]). For every property P ⊆ Σ * and parameters α ∈ [0, 1) and ε ∈ (0, 1), an algorithm T is an α-offline-erasure-resilient ε-tester for P if, given a parameter n ∈ N and oracle access to an α-erased input x ∈ Σ n , the algorithm T accepts with probability at least 2 3 whenever there exists a completion y ∈ P of x and rejects with probability at least 2 3 whenever every completion y of x is ε-far from P. When α = 0, the α-offline-erasure-resilient model is the same as the standard model. Another generalization of property testing is tolerant testing, introduced by [25] and extensively studied over the last decades. It can be viewed as guaranteeing resilience to an α fraction of the input being corrupted by an offline adversary. ▶ Definition 2.5 ((α, ε)-tolerant tester [25]). For every property P ⊆ Σ * and parameters α, ε ∈ (0, 1), an algorithm T is an (α, ε)-tolerant tester for P if, given a parameter n ∈ N and oracle access to input x ∈ Σ n , the algorithm T accepts with probability at least 2 3 whenever x is α-close to P and rejects with probability at least 2 3 whenever x is ε-far from P. When we want to stress comparison to other models we study, we call an (α, ε)-tolerant tester an α-offline-corruption-resilient ε-tester. E. Kelman, E. Linder, and S. Raskhodnikova
In this model, the input string x ∈ Σ n is accessed via an adversarial oracle O. After answering each query made by the algorithm, the adversary can erase or corrupt a small number of data points. At the beginning of the execution of the algorithm,
So, the first query is always answered correctly. The number of queries the adversary can manipulate after answering each query is parameterized by t ∈ N. The manipulated values are used by the oracle to answer future queries to the corresponding indices. The algorithm does not know which input locations have been tempered with. As stated in [21], "the actions of the oracle can depend on the input, the queries made so far, and even on the publicly known code that the algorithm is running, but not on future coin tosses of the algorithm." ▶ Definition 2.6 (Adversarial oracle, online testers [21]). Fix t ∈ N. A t-online-erasure oracle can replace values O(i) on up to t indices i ∈ [n] with the erasure symbol ⊥ after answering each query. A t-online-corruption oracle is defined analogously, except that it replaces each symbol with an arbitrary symbol from Σ instead of erasing it. For each t ∈ N, a t-online-erasure-resilient ε-tester T is defined as in the standard model (Definition 2.2), except that it accesses its input via a t-online-erasure oracle as opposed to querying the input directly. The t-online-corruption-resilient ε-tester is defined analogously.
The standard property testing model is a special case of this enhanced model and corresponds to the case when t = 0. Moreover, it is clear from the definition that testing with online erasures is no harder than testing with online corruptions. Specifically, every t-online-corruption-resilient tester can be simulated by a tester that accesses its input via a t-online-erasure oracle -the tester can simply replace each ⊥ with an arbitrary value from Σ.
In this section, we prove that testing with an offline adversary can require more queries than testing with an online adversary.
▶ Theorem 3.1 (Query complexity separation). Fix ℓ ∈ N and let r = r(n) < n be a function of the input length n. There exists a property P ⊆ {0, 1} * and a constant ε 1 = ε 1 (ℓ) ∈ (0, 1) such that: 5 1. For all ε ∈ (0, 1) and t = ( ε 2 ) O(ℓ) • r, the property P is t-online-corruption-resiliently ε-testable using ( 2 ε ) O(ℓ) queries. 2. For all n ∈ N, ε ∈ (0, ε 1 ), and α = Ω
queries on inputs of length n.
For ℓ = 1 and r = n log n , we obtain the following corollary.
There exist a property P such that for all ε ∈ (0, 1) and t ≤ poly(ε) • n log n , the property P is ε-testable using poly( 1 ε ) queries in the t-online-corruption model. However, for all α = Ω 1 log log n such that α + ε < 1, every α-offline-erasure-resilient ε-tester requires Ω(log n) queries. 5 We use log (ℓ) to denote the log function applied ℓ times.
While Corollary 3.2 shows that testing in the α-offline-erasure model can be harder than testing in the t-online-model for large t and small α, the difference in query complexity is quite mild. To obtain a large gap in query complexity from Theorem 3.1, we fix ℓ ∈ N and constant proximity parameter ε ≤ ε 1 (ℓ), and r = r(ε, ℓ) such that t = 1. This yields the following corollary.
▶ Corollary 3.3. Fix ℓ ∈ N and a constant ε = ε(ℓ). There exists a property P such that P is ε-testable in the 1-online-corruption model using constantly many queries. But, for all α = Ω 1 log (ℓ) n such that α + ε < 1, every α-offline-erasure-resilient ε-tester requires
One feature of the results in Theorem 3.1 (as well as Corollaries 3.2 and 3.3) is that they hold even when the adversary in the online model is allowed to make corruptions, while the adversary in the offline model is restricted to erasures.
To prove Theorem 3.1, we introduce the following "lifting" result (Lemma 3.5). Informally, the lemma states that every property P that is testable in the standard model has an encoding P ′ that is testable with the same query complexity even in the presence of an online-corruption adversary. This result allows us to transfer existing separations between the standard model and the offline-erasure model to a separation between the online-corruption model and the offline-erasure model.
To "lift" a property P, we simply encoded it with a repetition code, that is, repeat the corresponding input string.
▶ Definition 3.4 (r-concatenated string x r and property P r ). For all r ∈ N and strings x, let x r denote the concatenation of r copies of x, written
Additionally, for a property P of strings, let P r denote the property {x r : x ∈ P}.
Our lifting lemma holds for properties of strings over any alphabet. ▶ Lemma 3.5 (Lifting lemma). Let Σ be an alphabet and δ ∈ (0, 1) be a sufficiently small constant. Let P ⊆ Σ * be a property of strings that is ε-testable in the standard model using q(m, ε) queries on inputs of length m, where q(m, ε) = Ω 1 ε . Then, for all r ∈ N and t ≤ δ•r [q(m, ε
2 ) log q(m, ε
2 )] 2 , the property P r is t-online-corruption-resiliently ε-testable using O(q(m, ε
2 )) queries on inputs of length n = m • r.
Next we use Lemma 3.5 to prove Theorem 3.1, deferring the proof of Lemma 3.5 to Section 3.1. We leverage the following result of Ben-Eliezer, Fisher, Levi, and Rothblum [5], which separates the offline-erasure-resilient model from the standard model. ▶ Theorem 3.6 ([5, Theorem 6.2]). For all constant ℓ ∈ N, there exist a property Q (ℓ) ⊆ {0, 1} * and a constant ε 1 = ε 1 (ℓ) ∈ (0, 1) such that the following hold: 1. For every ε ∈ (0, 1), the property
Proof of Theorem 3.1. Fix ℓ ∈ N and let m, r ∈ N be sufficiently large. Let P denote the property Q (ℓ) of strings of length m given by Theorem 3.6. By Theorem 3.6, the property P can be ε-tested using 2 ε O(ℓ) queries. Thus, Lemma 3.5 guarantees that for all t = ( ε 2 ) O(ℓ) • r, the property P r is t-online-corruption-resiliently ε-testable using 2 ε O(ℓ) queries on inputs of length n = mr. E. Kelman, E. Linder, and S. Raskhodnikova
Now we prove that P r requires Ω n r polylog (ℓ) (n/r) queries to ε-test in the α-offlineerasure-resilient model. To do that, we show how to use any α-offline-erasure-resilient ε-tester T r for P r to construct an α-offline-erasure-resilient ε-tester T for P with the same query complexity as T r . Given a string x r , let x r [i] j denote index j of the i-th copy of x. Observe that for every α-erased input x, the string x r is also α-erased and the distance of x from P is the same as the distance of x r from P r ; moreover, for all i ∈ [r] and j ∈ [m], we have x r [i] j = x j . Thus, the tester T , given query access to x, can simulate T r executed with query access to x r and output the result given by T r . By Theorem 3.6, the tester T r has query complexity
Recall that Lemma 3.5 states that if a property P is testable in the standard model, then the property P r is testable in the online-corruption model. Let T be an ε-tester for P that has failure probability 1 12 , and query complexity c 0 • q(m, ε) for some constant c 0 > 0 (we can obtain such a tester via standard amplification techniques). We construct a tester T ′ for P r (Algorithm 1) and show that it is t-online-corruption-resilient. The tester T ′ consists of two phases: first, T ′ (s) calls repetition-test (Algorithm 2) to test that s is a repetition of some string, w, and second, T ′ (s) simulates T with query access to w.
For a string s of length n = r • m composed of r substrings each of length m, we use the notation s[i] j to denote index j, in the i-th substring of s.
Parameters: length parameter m, repetition parameter r, proximity parameter ε ∈ (0, 1) Input: query access to string s = s [1]
Subroutines: repetition-test (Algorithm 2) and c 0 • q(m, ε)-query tester T for P
2 ) rejects then reject 3: simulate T with proximity parameter ε 2 , answering each query j made by T as follows: sample a set of
else provide the answer s[i 1 ] j to T 4: if the simulation of T rejects then reject 5: else accept Algorithm 2 repetition-test.
Parameters: length parameter m, repetition parameter r, proximity parameter ε ∈ (0, 1) Input: query access to string s
▷ Claim 3.7. For all alphabets Σ and parameters ε ∈ (0, 1) and r, m ∈ N, repetition-test is a one-sided error ε-tester for the repetition code defined as C m,r = {s r : s ∈ Σ m }. It makes O( 1ε ) queries and has error probability at most 1 6 .
where
, be the input string over the alphabet Σ. If s ∈ C m,r , then repetition-test always accepts s. Suppose that string s is ε-far from C m,r . Let plurality i∈[r] (a i ) denote a function that takes inputs a 1 , . . . , a r ∈ Σ and outputs the most frequent among them, resolving ties arbitrarily. Let ŵ be the string of length m defined by ŵj = plurality i∈[r] s[i] j for all j ∈ [m]. Since s is ε-far from C m,r , we can bound the distance between the input string and ŵ repeated r times:
For all j ∈ [m] and a ∈ Σ, let p j (a) denote Pr i∈ [r] [s[i] j = a], the probability that a randomly chosen repetition of the j-th character in s is equal to a. The probability that one iteration of the loop in repetition-test accepts s is
Hence, each iteration of the loop in repetition-test rejects with probability at least ε. Therefore, repetition-test accepts s with probability at most (1 -ε)
. ◁ Next, we analyze the tester T ′ .
▷ Claim 3.8 (T ′ is a tester in the standard model). For all ε ∈ (0, 1),r ∈ N, alphabets Σ, and properties P ∈ Σ * , Algorithm 1 is an ε-tester for P r in the standard model (without any adversary). Moreover, it accepts ε-far inputs with probability at most 1 6 , and has one-sided error whenever T has one-sided error.
Proof. If the input s is in P r then s = w r for some string w ∈ P. In this case, repetitiontest accepts with probability 1, and T ′ accepts with the same probability as T . Next, suppose s is ε-far from P r . Consider the string ŵ ∈ Σ m , where ŵj = plurality i∈[r] s[i] j for all j ∈ [m]. Recall that the repetition code is defined as C m,r = {s r : s ∈ Σ m }. Observe that the distance from s to C m,r is equal to δ H (s, ŵr ). If this distance is at least ε 2 then, by Claim 3.7, repetition-test accepts with probability at most 1 6 , completing the proof. Now assume δ H (s, ŵr ) < ε 2 . We will show that, in this case, the simulation of T in Algorithm 1 accepts with probability at most 1 6 . Specifically, we consider two failure events: let E 1 be the event that the simulation of T feeds T at least one query answer inconsistent with ŵ, and E 2 be the event that the simulation of T accepts string ŵ. We will show that Pr[E 1 ] ≤ 1 12 and Pr[E 2 ] ≤ 1 12 . Then a union bound over E 1 and E 2 completes the proof.
Since s is ε-far from P r and δ H (s, ŵr ) < ε 2 , we get
implying that δ H ( ŵ, P) ≥ ε 2 . Since T is a tester for P with amplified success probability, and ŵ is ε 2 -far from P, algorithm T accepts with probability at most 1 12 when run on input ŵ and with proximity parameter ε 2 ; that is,
and let a j denote the answer provided by T ′ to query j in the simulation. If T ′ does not reject while simulating this query, then
The inequality in (2) follows from the following simple observation: once s[i 1 ] j has been sampled, if it is not the plurality, then for each k ∈ {2, . . . , d}, every subsequent s[i k ] j is equal to s[i 1 ] j with probability at most 1 2 . By our choice of c 1 , and a union bound over all the c 0 • q(m, ε/2) queries made by T , the probability of E 1 is at most 1 12 . Since T ′ can accept only if E 1 ∪ E 2 occurs, a union bound over E 1 and E 2 implies that T ′ is indeed a tester for P r , and has error probability at most 1 6 when no adversary is present. ◁ Finally, we prove the lifting lemma.
Proof of Lemma 3.5. First, we argue that the probability T ′ (Algorithm 1) queries a corrupted index is small. Recall that n = m • r is the length of the input to T ′ and that c 0 • q(m, ε) is the query complexity of T with proximity parameter ε.
)) be the number of queries made by T ′ . Then, there are at most q ′ t corruptions at any point during the execution. Moreover, each query made by T ′ is an index that is uniform over the set of corresponding indices in the r different segments of s. It follows that each query made by T ′ is corrupted with probability at most q ′ t r . By a union bound over the q ′ queries,
The upper bound follows from the hypothesis that t ≤
ε , and that δ is a sufficiently small constant. By a union bound, the probability that T ′ errs in the presence of the adversary is at most the probability T ′ errs when no adversary is present plus the probability T ′ queries a corrupted index. By Claim 3.8 and (3), this probability is at most 1 3 , which completes the proof of Lemma 3.5. ◀
In this section, we prove our result separating the randomness complexity of testing in the online and offline models. n ⊆ [n] n , and an algorithm T that takes ε ∈ (0, 1) as an input and, for all ε ∈ (0, 1), is a one-sided error ε-tester for P (τ ) that make O( τ ε ) queries. Additionally, the following hold: 1. For all ε, α ∈ (0, 1), tester T is an α-offline-erasure-resilient ε-tester for P (τ ) . Moreover, T can be simulated using O(log n) random bits and no additional queries.
For all ε ∈ (0, 1) and t ≤ 0.01ε
, tester T is a t-online-erasure-resilient ε-tester for P (τ ) . 3. There exists a constant ε > 0 such that for all t ∈ N and τ ≤ 0.01 √ n log n , every t-onlineerasure-resilient ε-tester for P (τ ) uses Ω τ log(t+1) log τ random bits. Moreover, if the tester has one-sided error, then it uses Ω(τ log(t + 1)) random bits.
√ n log n queries in the presence of either an online or offline adversary. The offline-erasureresilient tester uses O(log n) random bits, but there exists a constant ε such that every 1-online-erasure-resilient ε-tester, requires Ω √ n polylog n random bits to succeed with constant probability. Moreover, if the 1-online-erasure-resilient tester has one-sided error then it requires Ω( √ n) random bits.
To prove our randomness lower bound, we present a general reduction from randomnessefficient testers in the online-erasure model to query-efficient testers in the standard model. ▶ Lemma 4.3 (Generalization of Lemma 1.6). For all r, t ∈ N and properties P, if P is ε-testable in the presence of a t-online-erasure adversary using only r bits of randomness then P is ε-testable in the standard model using at most r log(t+1) queries. Proof. Let T be a t-online-erasure-resilient ε-tester for P that uses at most r random bits. We construct an adversary that allows T to make at most r log(t+1) non-erased queries. Consider the following random seed elimination adversary A. Given an input x, the description of algorithm T , and query-answer history of T on input x, the adversary simulates the next query of T on every random seed s ∈ {0, 1} r that is consistent with the query-answer history of T thus far and erases the t most queried indices of x. Intuitively, these are the indices that are most likely to be queried by the tester at this step, based on the random seeds that are consistent with the current query-answer history. Each index that the oracle decides not to erase at this step can appear in at most 1 t+1 fraction of currently relevant random seeds. If T queries such an index, all random seeds that would have lead to a different query can be eliminated. Thus, each time T makes a non-erased query, at most a 1 t+1 fraction of the relevant random seeds remain. Consequently, T can make at most r log(t+1) non-erased queries before A can exactly determine the random seed being used. Once A determines the random seed, it can exactly predict the queries of T and erase all of them.
Next, we use the adversary strategy A to construct an r log(t+1) -query tester for P. Let T * be defined as follows. Draw a random seed s * ∈ {0, 1} r and simulate T with random seed s * . After making each query, T * simulates A with the query-answer history of T . If A erases the next query of T , then T * answers the query with ⊥ and continues the simulation (the algorithm T * need not make any queries in this case). Otherwise, if A does not erase the next query of T , then T * queries x, provides T with the answer, and continues the simulation. Since T makes at most r log(t+1) non-erased queries and successfully tests P, the algorithm T * makes at most r log(t+1) queries and also successfully tests P. ◀
The property testing problem we use to prove Theorem 4.1 is a version of support size approximation. In support size approximation, one is given sample access to a distribution D over the domain [n] and asked to approximate |supp(D)| up to additive error ε. We study the analogous testing problem over strings: Given parameters τ ∈ N and ε ∈ (0, 1), and a string x of length n, we wish to ε-test whether |{x 1 , x 2 , . . . , x n }| ≤ τ , that is, to determine whether x has at most τ distinct elements or x is ε-far from every x ′ (of length n) with at most τ distinct elements.
▶ Definition 4.4 (τ -Distinct-Elements). For all n ∈ N and τ = τ (n), let P (τ ) n be the set of strings in [n] n with at most τ distinct symbols. The property τ -Distinct-Elements is defined as
The following tester for τ -Distinct-Elements appeared in [17]. We include the analysis of its guarantees here for completeness. ▷ Fact 4.5 (A tester for τ -Distinct-Elements). For all ε ∈ (0, 1), there exists a one-sided error tester for P (τ ) that uses O( τ ε ) samples and fails with probability at most 1 10 .
Proof. We first make the following observation: if x is ε-far from P (τ ) , then every collection of τ distinct elements occupies at most a 1 -ε fraction of the indices in x. Suppose we sample uniformly random elements from x until we have seen τ + 1 distinct elements. Notice that while we have seen at most τ distinct elements, our next sample is a new distinct element with probability at least ε (the at most τ distinct elements we have seen can have probability mass at most 1 -ε). Let X i be the number of samples to get the i-th distinct element given we have seen i -1 distinct elements, and set X = τ +1 i=1 X i . Then E[X] ≤ (τ + 1)/ε, and hence, by Markov's inequality, the probability we need more than 3(τ + 1)/ε samples is at most 1 3 . This analysis inspires the following simple tester: Sample s = 3(τ + 1)/ε elements from x and accept if and only if there are at most τ distinct symbols from [n] in the sample (not counting the erasure symbol ⊥).
Repeating the tester constantly many times suffices to make the failure probability smaller than 1 10 . ◁
Recall that Lemma 4.3 states that to prove a lower bound on the randomness complexity of testing in the online model, it suffices to prove a lower bound on the query complexity of testing in the standard model. In Lemma 4.6, we show a lower bound on the query complexity of testing τ -Distinct-Elements. Our lower bound is a direct corollary of the lower bound of [32].
▶ Lemma 4.6 (Query lower bound for testing τ -Distinct-Elements). There exists ε ∈ (0, 1) such that for all input lengths n, if τ ≤ √ n log n , then the query complexity of ε-testing P (τ ) is Ω( τ log τ ). Moreover, the query complexity of ε-testing P (τ ) with one-sided error is Ω(τ ).
Proof. We use the following fact to argue that we can assume the tester is sample-based with no loss of generality.
I T C S 2 0 2 5 65:14 Online Versus Offline Adversaries in Property Testing ▷ Fact 4.7 (Theorem 6.1 [16]). A property of strings is symmetric if it is closed under permutations of the string indices (that is, under reordering of the characters in the string).
Let P be a symmetric property of strings that is ε-testable with query complexity q. Then there exists a sample-based tester for P with sample complexity O(q).
Since P (τ ) is symmetric, we can without loss of generality consider sample-based testers. First, we prove the lower bound for two-sided error testers. The essence of our proof is a reduction from the hard instances used in [32] for estimating the support size of a distribution. While we cannot use the lower bound of [32] as a black box, we can nonetheless leverage their hard instances. Indeed, combining Theorem 1, Fact 5, and the remarks regarding the support size of their hard distributions (following Definition 12) from [32], we obtain the following immediate corollary.
▷ Fact 4.8 (Support size approximation lower bound [32]). Let α > 0 be a sufficiently small constant.
There exist distributions D + and D -over [m] such that 1. Every element in the support of D + or D -has probability mass at least 1 m . 2. |supp(D + )| ≤ m 1 2 + α , and D -is 1 2 -2α -far from every distribution with support size at most m 1 2 + α . Moreover, every algorithm that successfully distinguishes D + from D -with constant probability requires Ω m log m samples.
While the distributions in [32] are defined over R, they all have support size at most m. Thus, we can, without loss of generality, consider distributions over n log n from D. Thus, for sufficiently large n, there exist strings x + , x -∈ [m] n such that x + has at most m( 1 2 + α) distinct symbols, and the distributions generated by sampling from x + and x -have total variation distance 1 √ n log n from D + and D -, respectively. Let τ = m( 1 2 + α) and ε = 1 2 -2α -o(1), then x + ∈ P (τ ) and x -is ε-far from P (τ ) . By Fact 4.8, every algorithm for distinguishing x + from x -uses Ω m log m = Ω τ log τ samples. By Fact 4.7, every tester for P (τ ) has query complexity Ω τ log τ . To prove the one-sided error lower bound, it suffices to note that every one-sided error algorithm must accept if its sample contains at most τ symbols. Thus, every one-sided error tester requires Ω(τ ) samples. This completes the proof of Lemma 4.6. ◀
To complete the proof of the theorem, we argue that the tester given by Fact 4.5 is a valid tester for τ -Distinct-Elements in both the online and offline erasure models. To prove the lower bound on the randomness complexity of testing τ -Distinct-Elements in the online model, we combine the query lower bound of Lemma 4.6 with the reduction stated in Lemma 4.3. To prove the upper bound on the randomness complexity of testing τ -Distinct-Elements in the offline model, we argue that the offline tester can be simulated with few bits of randomness at a small cost in error probability. We first prove the part of the theorem regarding testing τ -Distinct-Elements in the offline erasure model.
Proof of Theorem 4.1, Item 1. First, for all τ ∈ N, we construct an offline-erasure-resilient tester for τ -Distinct-Elements, and second, we argue that the tester can be simulated with O(log n) random bits and no additional queries. Let T be the tester given by Fact 4.5. Recall that T accepts if and only if the number of nonerased symbols in the sample is at most τ . Below, we argue that T is an α-offline-erasure-resilient ε-tester.
Let x be an α-erased string in [n] n . If some completion of x is in P (τ ) , then the number of nonerased symbols in the sample drawn by T is at most τ , so the algorithm accepts. Next we argue that T accepts with probability at most 1 4 when every completion of x is ε-far from P (τ ) . Let x ⊥ denote the erased portion of x, and x ⊤ denote the nonerased portion of x. Notice that |x ⊤ | = (1 -α)n, and thus if x ⊤ is ε 1-α -close to P (τ ) , then there is a completion of x that is ε-close to P (τ ) (change εn symbols in x ⊤ and fill out x ⊥ with an arbitrary symbol from x ⊤ ). Thus, if every completion of x is ε-far from P (τ ) , then x ⊤ is ε 1-α -far from P (τ ) . By the proof of Fact 4.5, a set of O τ (1-α) ε uniform and independent samples from x ⊤ contains at least τ + 1 distinct symbols with probability at least 9 10 . Moreover, a sample of O τ ε elements from x contains Ω τ (1-α) ε such samples from x ⊤ with probability at least 9 10 . By the union bound, T accepts x with probability at most 1 4 . It remains to show that T can be simulated by a tester T ′ that uses O(log n) random bits and has the same query complexity as T . Fact 4.9 states that any randomized oracle machine that solves a promise problem can be simulated using log n + log log |Σ| + O(1) random bits, where |Σ| is the size of the alphabet. This fact was originally proven by Goldreich and Sheffet [18] and is stated as an exercise in [14]. We use the statement from the exercise since it is more convenient for our setting.
▷ Fact 4.9 (Exercise 1.21 [14]). Fix n ∈ N and let Π be a promise problem regarding strings in Σ n . Suppose that M is a randomized q-query oracle machine that solves Π with error probability at most 1 4 . Then there exists a randomized q-query oracle machine M ′ that solves Π with error probability at most 1 3 and log n + log log |Σ| + O(1) random bits.
Let Π be the promise problem defined by α-offline-erasure-resilient ε-testing P (τ ) . By the first part of the proof, there exists a randomized oracle machine T that solves Π with error probability at most 1 4 . Applying Fact 4.9 directly, we see that T can be simulated by a tester T ′ using log n + log log |Σ| + O(1) random bits; since Σ = [n], tester T ′ uses O(log n) random bits, and has error probability at most 1 3 . To complete the proof, it suffices to note that T ′ has the same query complexity as T . ◀
Next, we prove the part of the theorem regarding testing τ -Distinct-Elements in the online erasure model.
Proof of Theorem 4.1, Items 2 and 3. We will show that for all τ ∈ N, the tester given by Fact 4.5 is online-erasure-resilient. Let T be the tester for τ -Distinct-Elements given by Fact 4.5. Recall that T accepts if and only if the number of nonerased symbols in its sample is at most τ . We show that T can test in the presence of a t-online-erasure-oracle, by arguing that with high constant probability, none of the queries made by T are erased. Notice that with proximity parameter ε, the tester makes O τ ε queries. Thus, there are
T C S 2 0 2 5 65:16 Online Versus Offline Adversaries in Property Testing O t•τ ε erasures at every point during the execution of T . Since T makes uniform and independent queries, the probability that any particular query is erased is O t•τ nε . Since T makes O τ ε queries, we can apply the union bound to see that some query is erased with probability at most O t•τ 2 nε 2 . By the hypothesis that t ≤ .01ε √ n τ 2 , we have O t•τ 2 nε 2
≤ .01 -that is, T sees an erasure with probability at most .01. By Fact 4.5, the algorithm T is a t-online-erasure-resilient ε-tester for P (τ ) . Moreover, since an erasure cannot increase number of distinct nonerased symbols in x, tester T has one-sided error. This completes the proof of Item 2.
To see why Item 3 holds, recall that by Lemma 4.6, there exists ε ∈ (0, 1) such that for all n, τ ∈ N with τ ≤
√ n log n , every ε-tester for P (τ ) has query complexity Ω τ log τ . Similarly every tester with one-sided error has query complexity Ω(τ ). Thus, applying Lemma 4.3, the reduction from query complexity to randomness complexity, suffices to complete the proof.
◀
In contrast, in the offline models, testing is always possible when the entire input is read.
In this case, the tester in the offline model is deterministic. Note that it is impossible to deterministically test any nontrivial property in the online model, since the adversary can erase all but the first query made by a deterministic tester.