Abstract 1 Introduction 2 Preliminaries 3 Tight Lower Bound on the Adaptivity Gap 4 PTAS for the Unit-Cost Case 5 Conclusion References

Non-Adaptive Evaluation of π’Œ-of-𝒏 Functions:
Tight Gap and a Unit-Cost PTAS

Mads Anker Nielsen ORCID Department of Mathematics and Computer Science, University of Cologne, Germany Lars Rohwedder ORCID Department of Mathematics and Computer Science, University of Southern Denmark, Odense, Denmark Kevin Schewior ORCID Department of Mathematics and Computer Science, University of Cologne, Germany
Department of Mathematics and Computer Science, University of Southern Denmark, Odense, Denmark
Abstract

We consider the Stochastic Boolean Function Evaluation (SBFE) problem in the well-studied case of k-of-n functions: There are independent Boolean random variables x1,…,xn where each variable i has a known probability pi of taking value 1, and a known cost ci that can be paid to find out its value. The value of the function is 1 iff there are at least k 1s among the variables. The goal is to efficiently compute a strategy that, at minimum expected cost, tests the variables until the function value is determined. While an elegant polynomial-time exact algorithm is known when tests can be made adaptively, we focus on the non-adaptive variant, for which much less is known.

First, we show a clean and tight lower bound of 2 on the adaptivity gap, i.e., the worst-case multiplicative loss in the objective function caused by disallowing adaptivity, of the problem. This improves the tight lower bound of 3/2 for the unit-cost variant.

Second, we give a PTAS for computing the best non-adaptive strategy in the unit-cost case, the first PTAS for an SBFE problem. At the core, our scheme establishes a novel notion of two-sided dominance (w.r.t. the optimal solution) by guessing so-called milestone tests for a set of carefully chosen buckets of tests. To turn this technique into a polynomial-time algorithm, we use a decomposition approach paired with a random-shift argument.

Keywords and phrases:
Approximation scheme, Boolean functions, stochastic combinatorial optimization, stochastic function evaluation, sequential testing, adaptivity
Category:
APPROX
Funding:
Kevin Schewior: Supported in part by the Independent Research Fund Denmark, Natural Sciences, grant DFF-4283-00079B.
Copyright and License:
[Uncaptioned image] © Mads Anker Nielsen, Lars Rohwedder, and Kevin Schewior; licensed under Creative Commons License CC-BY 4.0
2012 ACM Subject Classification:
Theory of computation β†’ Approximation algorithms analysis
Related Version:
Full Version: https://arxiv.org/abs/2507.05877
Editors:
Alina Ene and Eshan Chattopadhyay

1 Introduction

The Stochastic Boolean Function Evaluation (SBFE) problem is a fundamental problem in stochastic combinatorial optimization, see e.g. the survey by ÜnlΓΌyurt [24] or the more recent works [6, 9, 16]. A function f:{0,1}nβ†’{0,1} is given (typically in compact representation), and the task is to find out f⁒(x1,…,xn) where x1,…⁒xn are independent Boolean random variables. For each i∈[n], pi∈(0,1) is the known probability that xi=1, and the value of xi can be learned by a policy at known cost ciβ‰₯0.

There are two fundamental paradigms for policies: the adaptive one and the non-adaptive one. An adaptive policy may make decisions to test variables depending on the outcomes of previous tests, i.e., it can be viewed as a decision tree. A non-adaptive policy, in contrast, is simply specified by an order of variables to test, which may not be adapted depending on the outcomes of tests. In either case, policies are evaluated by the expected cost paid until the value of f is determined (with probability 1). While non-adaptive policies have a simple representation, are easy to execute, and are therefore often desirable from a practical point of view, they are generally subobtimal. The adaptivity gap [5, 14] of a class of functions measures the severity of precisely this suboptimality: the worst-case (in this class of functions) multiplicative gap between the expected cost of the best non-adaptive policy and that of the best adaptive policy.

An important class of functions are k-of-n functions. Such a function is simply given by an integer k∈[n], and the function value is 1 if and only if there are at least k 1s among the input variables, i.e., x1+β‹―+xnβ‰₯k. SBFE has also been considered for a number of more general classes of functions, e.g., linear threshold functions [6, 18, 9], symmetric Boolean functions [11, 9, 20, 21], and voting functions [16]. For many of these classes, polynomial-time approximation algorithms to compute the best non-adaptive or adaptive policy have been proposed.

Apart from it occurring as a special case of many SBFE problems studied in the literature, another reason for the popularity of k-of-n functions may be the elegance of the optimal policy [22, 2]: Conditional on function value 0 and 1, it is optimal to test in increasing order of ci/(1βˆ’pi) and ci/pi ratios, respectively, to find a certificate at minimum expected cost. Since these policies need to test at least nβˆ’k+1 and k tests, respectively, to find a certificate, there is, by the pigeon-hole principle, some test occurring in both these prefixes, which can safely be tested even in the original (unconditional) case.

When non-adaptive policies come into play, however, much less is known. First, while it is known that, in the unit-cost case the adaptivity gap is exactly 3/2 [12, 21], no stronger lower bound for the general case is known, with the upper bound only being 2 [10]. Second, the polynomial-time approximation algorithms implied by the upper-bound proofs on the adaptivity gaps are those with the best known approximation ratios, i.e., 3/2 in the unit-cost case and 2 in the general case. In this paper, we make significant progress on both questions.

1.1 Our Contribution

Our first result is the following.

Theorem 1.

The adaptivity gap of SBFE on k-of-n functions is exactly 2.

This settles an open question that had been known within the community and is explicitly stated in [21]. Since an upper bound of 2 was known [10], our contribution is showing a matching lower bound. Our construction is perhaps surprisingly simple.

To give an overview, let us first recall the class of instances for the unit-cost version which leads to a lower bound of 3/2 [21]. Here, n=2⁒t+1 for some integer t, and k=t+1. There are t 1-variables taking value 1 and t 0-variables taking value 0. Note that we do not allow probabilities of precisely 0 or 1 in our model, but we do in this section for the simplicity of exposition. Such variables still have to be tested in order to use them towards certifying the function value. In addition, there is a single pivotal variable with probability 1/2, whose value thus determines the function value. An adaptive policy can simply test the pivotal variable, having, say, value i, and then test all the i-variables, at expected cost of t+1. A non-adaptive policy, on the other hand, can only β€œguess” the outcome of the pivotal variable, resulting in an expected cost of 3/2β‹…t+1. Then taking the limit tβ†’βˆž yields the result.

Note that, in the arbitrary-cost case, we can simply assign the pivotal variable a cost of 0, so that t=1 would actually suffice to obtain a bound of 3/2. The main idea of our construction is to have several, say, m, pivotal variables, all with probability 1/2 and cost 0. It is easy to see that, with t=1, the resulting ratio is still 3/2. The correct regime turns out to be the one in which t is large but m is much larger than t. In that case, if one is not done after performing the pivotal tests (which are free), the function value is determined to be 0 or 1 with probability 1/2 each, and the number of tests required to prove that is (in the limit) uniformly distributed between 1 and t. These quantities are revealed to an adaptive policy but not to a non-adaptive policy. Hence, in the limit, the cost of an adaptive policy is 1/tβ‹…βˆ‘i=1ti=(t+1)/2 and for a non-adaptive policy, which is done at any step during the remaining 2⁒t steps with equal probability, 1/(2⁒t)β‹…βˆ‘i=12⁒ti=(2⁒t+1)/2. The result then follows with tβ†’βˆž.

Our second result is not structural but algorithmic.

Theorem 2.

There is a PTAS for computing the optimal non-adaptive policy for evaluating k-of-n functions in the unit-cost case.

Notably, this is the first PTAS for an SBFE problem. The PTAS relies on the idea of carefully enumerating a polynomial number of policies. We denote the optimal policy by π⋆. Ideally, we would like to guarantee that among the enumerated policies there is one policy Ο€ which satisfies for all i that

Pr⁑[cost⁒(Ο€)β‰₯i]≀Pr⁑[(1+Ξ΅)⁒cost⁒(π⋆)β‰₯i].

This would be enough to show that E⁑[cost⁒(Ο€)]≀(1+Ξ΅)⁒E⁑[cost⁒(π⋆)].

It would be possible, albeit non-trivial, to get this property in quasi-polynomial time: View a policy as a sequence of buckets (containing tests) of exponentially increasing size, so that it essentially does not matter (in terms of a (1+Ξ΅)-approximation) where one finishes in the bucket. Then, starting from the left, for each bucket, apply our core idea: In the corresponding bucket of π⋆, sort all variables by their probability. In this order, we guess 1/Ξ΅ equally spaced tests. Our main structural result is to show that if one has correctly guessed these equally spaced tests, then only using a few extra tests in each bucket (as compared to the corresponding bucket in OPT) we can achieve a strong domination property that we will describe below.

Consider any prefix P of buckets of the algorithm and the corresponding prefix of buckets P⋆ of the optimum. Then our domination property says the following: There is an injection from the tests in P⋆ to those in P such that, for those in P the probability is at least that of the corresponding test in P⋆; moreover, the there also exists an injection for the other direction, i.e., one where the probability is at most as high. Crucially, this domination property allows us to argue that the probability that our policy determines f by performing the tests in P is at least as large as the probability of achieving the same goal by performing the tests in P⋆.

The reason that the described scheme is only a QPTAS is that the number of buckets is logarithmic and the algorithm guesses all combinations of possible milestones, across all buckets. To obtain a PTAS, we decompose our instance into subinstances that do not interact with each other. The subinstances are instances of a weaker variant, in which the above inequality only has to be fulfilled for a bounded range of values i, so that the number of buckets is also bounded. We use a random-shift argument to show that such a decomposition actually exists. Specifically, we show that we can find an offset of ranges at exponentially increasing times at which one can afford to β€œreset”, i.e., create a new subinstance that does not interact with any of the previous ones.

1.2 Further Related Work

As we focus exclusively on k-of-n functions, we only briefly review the SBFE literature for function classes other than those mentioned above. One example are functions that take value 1 iff there is an s-t path in a given graph, whose edges exist iff some input random variable is 1. This problem is NP-hard [8, 13] due to connections to the s-t reliability problem. Read-once formulas, which are equivalent to the same functions for series–parallel graphs, have also been extensively studied (see [24] for an overview), but optimal algorithms have only been obtained in special cases; in particular, no constant-factor approximations are known in the general case.

We list a few standard techniques for obtaining approximation algorithms for SBFE problems, all of which inherently incur constant-factor multiplicative losses that are not useful towards designing a PTAS: round-robin approaches (e.g., [19, 1, 21]), reducing to a submodular cover problem (e.g., [6, 15, 4]), and a round-based approach (e.g., [17, 7, 9]).

While there have previously not been PTASs for SBFE problems, PTASs have been developed for other problems in stochastic combinatorial optimization. Examples are stochastic probing and prophet problems [23] and the Pandora’s Box problem with non-obligatory inspection [3], but it is unclear whether these techniques can be used for SBFE problems. We hope that our work will spark follow-up work on PTASs for SBFE problems.

Finally, we remark that NP-hardness for computing optimal non-adaptive policies for k-of-n functions is not known. In many other cases (e.g., symmetric Boolean functions and voting functions), this state is the same, and approximation algorithms are developed as hardness is conjectured. In some cases NP-hardness simply follows because the corresponding deterministic problem is NP-hard (e.g., [6]); arguably, we lack techniques for establishing NP-hardness of SBFE problems more directly.

2 Preliminaries

Throughout the paper, we use β„•={1,2,…} and β„•0={0,1,2,…}. For mβˆˆβ„•, we use [m] as a shorthand for {1,…,m}.

We call a function f:{0,1}nβ†’{0,1} a Boolean function in n variables. A state s is a vector s∈{0,1,βˆ™}n. If s is a state and x∈{0,1}n, then we say that x follows from s if si∈{xi,βˆ™} for all i∈[n]. We say that f is determined by a state s if f takes the same value for all x∈{0,1} following from s.

In the SBFE problem, we are given a Boolean function f in n variables, a cost vector cβˆˆβ„n and a probability vector p∈(0,1)n. We assume w.l.o.g. that p1≀p2≀⋯≀pn. The values of the variables x1,x2,…,xn are initially unknown, and at each step, we must select a variable xi to test, upon which its value is revealed. We represent the current knowledge as a state vector s∈{0,1,βˆ™}n, where si is the currently known value of xi or βˆ™ if xi is unknown. We must continue testing variables exactly until f is determined by the current state s.

Formally, we can represent a policy as function Ο€:{0,1,βˆ™}nβˆ–{0,1}nβ†’[n] where xπ⁒(s) is the variable tested when currently in state s, with the requirement that sπ⁒(s)=βˆ™ for all states sβˆ‰{0,1}n (i.e., only variables with unknown value can be tested). If Ο€ tests exactly the set of variables with indices SβŠ†{1,2,…,n} (a random variable) before determining f, then the cost of Ο€ on input x with respect to cost vector c (a random variable) is denoted costc⁒(Ο€,x) and formally defined defined as

costc⁒(Ο€,x)=βˆ‘i∈Sci.

The expected cost Ep⁑[costc⁒(Ο€)] of Ο€ with respect to probability vector p and cost vector c is the expected value of costc⁒(Ο€) with respect to the probability distribution Pr given by

Pr⁒[x]=∏i∈[n]:xi=1pi⁒∏i∈[n]:xi=0(1βˆ’pi).

for all x∈{0,1}n. We omit the subscripts p and c from Ep and, respectively, costc when they are clear from context.

A policy Ο€ is non-adaptive if π⁒(s) only depends on the number of unknown variables in state s. We represent a non-adaptive policy simply as the fixed order (permutation) Οƒ of [n] such that xσ⁒(i) is the variable tested in the i-th step.

A partial non-adaptive policy Ο€ is a non-adaptive policy that stops early. It can be represented by a permutation Οƒ of a subset set⁒(Οƒ) of [n] where again xσ⁒(i) is the variable tested in the i-th step. If Ο€ determines the value of f, its cost is defined in the same way as for non-partial policies. If Ο€ does not determine the value of f, its cost is n.

Given two partial non-adaptive policies Ο€1,Ο€2, we denote by Ο€1βˆ˜Ο€2 the (possibly partial) non-adaptive policy that first tests in order of Ο€1 and then in order of Ο€2, skipping any test that has been conducted by Ο€1 already.

The optimal policy OPT⁒(f,c,p) (optimal non-adaptive policy OPTNA⁒(f,c,p)) of a function f with respect to cost vector c and probability vector p is the policy (non-adaptive policy) Ο€ for f which minimizes Ep⁑[costc⁒(Ο€)].

We define an instance of the SBFE problem as a triple I=(f,p,c) where f is a Boolean function, p if a probability vector, and c is a cost vector. For the purposes of determining the encoding length of an instance in the case of k-of-n functions, f is simply given by the integer k.

Finally, let ℐ be a class of instances (f,p,c) of the SBFE problem. (In this paper, we will only consider the case where f is a k-of-n function.) The adaptivity gap is defined as

sup(f,p,c)βˆˆβ„Ep⁑[costc⁒(OPTNA⁒(f,c,p))]Ep⁑[costc⁒(OPT⁒(f,c,p))].

3 Tight Lower Bound on the Adaptivity Gap

In this section, we show Theorem 1, which we restate here for convenience.

Theorem 1. [Restated, see original statement.]

The adaptivity gap of SBFE on k-of-n functions is exactly 2.

Recall that an upper bound of 2 is known [10], so we will proceed by proving a tight lower bound. Our family of lower-bound instances is defined as follows. For positive integers m,t and Ρ∈(0,1) (we only ever pick Ρ close to 0), define Lm,t,Ρ=(f,c,p) where f is the k-of-n function with k=m+t and n=2⁒m+2⁒t and

(ci,pi)={(1,Ξ΅)1≀i≀t(0,1/2)t<i≀2⁒m+t(1,1βˆ’Ξ΅)2⁒m+t<i≀2⁒m+2⁒t

for i∈[n]. To show the theorem, we will show that

limtβ†’βˆžlimmβ†’βˆžlimΞ΅β†’0E⁑[cost⁒(OPTNA⁒(Lm,t,Ξ΅))]E⁑[cost⁒(OPT⁒(Lm,t,Ξ΅))]=2.

Thus, one should think of Ξ΅ as being vanishingly small, of t as being large, and of m as being much larger than t.

We refer to the 2⁒m variables of Lm,t,Ξ΅ with ci=0 as free variables and the remaining 2⁒t variables as paid variables. Among the paid variables, we refer to those with pi=1βˆ’Ξ΅ as 1-variables and those with pi=Ξ΅ as 0-variables.111Note that, for an alternative proof, we could assume that the i-variables take value i with probability 1, for i∈{0,1}, and then use a continuity argument (or allow probabilities 0 or 1 in our model anyway). We denote by X the random variable such that X⁒(x)=|{t⁒<i≀2⁒m+t∣⁒xi=1}|, i.e., X is the number of 1s among the free variables.

We assume that an optimal policy for Lm,t,Ρ tests all free variables before testing any other variable. We call such a policy economical. This assumption is clearly without loss of generality since, if some policy is not economical, we can make it economical by moving all free variables to the front without increasing the cost of the policy for any x∈{0,1}n.

To get an intuition, one can think of the 1-variables and 0-variables as always taking value 0 and 1 respectively, which is true in the limit Ξ΅β†’0. Nevertheless, the policies may need to test them and, in particular, pay their cost, until the function is determined. This is where an adaptive policy has an advantage over a non-adaptive policy: after the free variables have been tested, an adaptive policy can behave optimally, since it already knows the function value. The non-adaptive policy, on the other hand, cannot use the outcome of the free tests and therefore has to hedge against both possible function values, which leads to the ratio of 2 as we will see in the remainder.

Since m is much larger than t, the event that the function value is not determined after performing the free tests (formally, Xβˆ’m∈[βˆ’t,tβˆ’1]) has low probability. Nevertheless, we observe in the following lemma (proven formally in the full version) that this is the only event in which the behavior of an economical policy matters.

Lemma 3.

Let m and t be any two integers with m>t, let Ρ∈(0,1) be arbitrary, and let X be as above. For any pair of economical policies Ο€ and Ο€β€² we have

E⁑[cost⁒(Ο€)]E⁑[cost⁒(Ο€β€²)]=E⁑[cost⁒(Ο€)∣Xβˆ’m∈[βˆ’t,tβˆ’1]]E⁑[cost⁒(Ο€β€²)∣Xβˆ’m∈[βˆ’t,tβˆ’1]].

Next, we show a technical lemma that states that, in the limit case, Xβˆ’m takes any integer value in the interval [βˆ’t,tβˆ’1] with the same probability. Intuitively, this follows from Lipschitzness of the normal distribution. The proof is deferred to the full version.

Lemma 4.

For any aβˆˆβ„•, let X2⁒a be a random variable drawn from a binomial distribution with parameters 2⁒a (number of trials) and 1/2 (success probability). Then, for any cβˆˆβ„• and integer i∈[βˆ’c,cβˆ’1], we have

limaβ†’βˆžPr⁑[X2⁒aβˆ’a=i∣X2⁒aβˆ’a∈[βˆ’c,cβˆ’1]]=12⁒c.

To prove Theorem 1, by the previous two lemmata, we may focus on the setting where Xβˆ’m is uniformly distributed in [βˆ’t,tβˆ’1]. We analyze the performance of an adaptive policy and that of a non-adaptive policy.

Proof of Theorem 1.

Let m,tβˆˆβ„• and Ρ∈(0,1) be arbitrary and let (f,c,p)=Lm,t,Ξ΅. Let X be as above. Since pi=1/2 for the 2⁒m variables xi with t<i<2⁒m+t contributing to X and t is a constant independent of m, Lemma 4 implies

limmβ†’βˆžE⁑[Xβˆ’m=i∣Xβˆ’m∈[βˆ’t,tβˆ’1]]=12⁒t (1)

for any integer i∈[βˆ’t,tβˆ’1].

Now, let Ο€ be the adaptive policy which on input x evaluates the free variables and then, if it has not yet determined f, evaluates all 1-variables first if X⁒(x)βˆ’mβ‰₯0 and otherwise evaluates all 0-variables first. Also, let Ο€NA be any economical non-adaptive policy. As Ο€NA is non-adaptive and economical, the last 2⁒t tests of Ο€NA are the paid variables of Lm,t,Ξ΅ in some fixed order σ⁒(1),σ⁒(2),…,σ⁒(2⁒t). For j∈[t], let n1⁒(j) be minimal such that there are exactly j 1-variables in {xσ⁒(1),xσ⁒(2),…,xσ⁒(n1⁒(j))} and let n0⁒(j) be minimal such that there are exactly j 0-variables {xσ⁒(1),xσ⁒(2),…,xσ⁒(n0⁒(j))}).

Claim 5.

Let x∈{0,1} be such that Xβˆ’m∈[βˆ’t,tβˆ’1] and xi=1 for all 1-variables xi and xj=0 for all 0-variables xj. Then

cost⁒(Ο€,x) ={kβˆ’X⁒(x)if ⁒X⁒(x)βˆ’mβ‰₯0(nβˆ’k+1)βˆ’(2⁒mβˆ’X⁒(x))if ⁒X⁒(x)βˆ’m<0⁒and
cost⁒(Ο€NA,x) ={n1⁒(kβˆ’X⁒(x))if ⁒X⁒(x)βˆ’mβ‰₯0n0⁒((nβˆ’k+1)βˆ’(2⁒mβˆ’X⁒(x)))if ⁒X⁒(x)βˆ’m<0.

Proof.

Suppose Xβˆ’mβ‰₯0. Since all t 1-variables evaluate to 1, there are X⁒(x)+tβ‰₯m+t=k 1s in x and so f⁒(x)=1. Thus, any economical policy has determined the value of f exactly when it has evaluated the (kβˆ’X⁒(x))-th 1-variable. Hence, by the definition of Ο€, cost⁒(Ο€,x)=kβˆ’X⁒(x), and by the definition of n1, cost⁒(Ο€NA,x)=n1⁒(kβˆ’X⁒(x)).

Suppose that X⁒(x)βˆ’m<0. Since all t 0-variables evaluate to 0, there are 2⁒mβˆ’X⁒(x)+tβ‰₯nβˆ’k+1 0s in x and so f⁒(x)=0. Thus, any economical policy has determined the value of f exactly when it has evaluated the ((nβˆ’k+1)βˆ’(2⁒mβˆ’X⁒(x)))-th 0-variable. Hence, by the definition of Ο€, cost⁒(Ο€,x)=(nβˆ’k+1)βˆ’(2⁒mβˆ’X⁒(x)), and by the definition of n0, cost⁒(Ο€NA,x)=n0⁒((nβˆ’k+1)βˆ’(2⁒mβˆ’X⁒(x))). ⊲

Note that the condition on x from Claim 5 (all i-variable take value i for i=0,1) holds with probability approaching 1 as Ξ΅ approaches 0. Using this observation and Claim 5, we will show that

limmβ†’βˆžlimΞ΅β†’0E⁑[cost⁒(Ο€NA)]E⁑[cost⁒(Ο€)]=2⁒t+1t+1,

from which the theorem follows by taking the limit as t approaches infinity. First, by Lemma 3, and since both expectations are between 0 and 2⁒t, the above ratio is equal to

limmβ†’βˆžlimΞ΅β†’0E⁑[cost⁒(Ο€NA)∣Xβˆ’m∈[βˆ’t,tβˆ’1]]limmβ†’βˆžlimΞ΅β†’0E⁑[cost⁒(Ο€)∣Xβˆ’m∈[βˆ’t,tβˆ’1]].

We first analyze the cost of Ο€:

limmβ†’βˆžlimΞ΅β†’0 E⁑[cost⁒(Ο€)∣X∈[βˆ’t,tβˆ’1]]
=limmβ†’βˆžlimΞ΅β†’0βˆ‘i=βˆ’ttβˆ’1Pr⁒[Xβˆ’m=i∣Xβˆ’m∈[βˆ’t,tβˆ’1]]β‹…E⁑[cost⁒(Ο€)∣Xβˆ’m=i]
=βˆ‘i=βˆ’ttβˆ’1limmβ†’βˆžPr⁒[Xβˆ’m=i∣Xβˆ’m∈[βˆ’t,tβˆ’1]]β‹…limΞ΅β†’0E⁑[cost⁒(Ο€)∣Xβˆ’m=i]
=12⁒t⁒(βˆ‘i=βˆ’tβˆ’1((nβˆ’k+1)βˆ’(2⁒mβˆ’(i+m)))+βˆ‘i=0tβˆ’1(kβˆ’(i+m)))
=12⁒t⁒(βˆ‘i=βˆ’tβˆ’1(t+i+1)+βˆ‘i=0tβˆ’1(tβˆ’i))
=12⁒t⁒(βˆ‘i=1ti+βˆ‘i=1ti)=1tβ’βˆ‘i=1ti=t⁒(t+1)2⁒t=t+12,

where the second equality is a consequence of the sum and product laws for limits, the third follows from Equation 1 and Claim 5.

Using an argument identical to the case of Ο€ in the first step, we see that for Ο€NA,

limmβ†’βˆžlimΞ΅β†’0 E⁑[cost⁒(Ο€NA)∣X∈[βˆ’t,tβˆ’1]]
=12⁒t(βˆ‘i=βˆ’tβˆ’1n0((nβˆ’k+1)βˆ’(2mβˆ’(i+m))+βˆ‘i=0tβˆ’1n1(kβˆ’(i+m)))
=12⁒t⁒(βˆ‘i=βˆ’tβˆ’1n0⁒(t+i+1)+βˆ‘i=0tβˆ’1n1⁒(tβˆ’i))
=12⁒t⁒(βˆ‘i=1tn0⁒(i)+βˆ‘i=1tn1⁒(i))=12⁒tβ’βˆ‘i=12⁒ti=2⁒t⁒(2⁒t+1)2β‹…2⁒t=2⁒t+12,

where, in the fourth equality, we used that

{n1⁒(i)∣i∈[t]}βˆͺ{n0⁒(i)∣i∈[t]}=[2⁒t]

since σ⁒(j) is either a 1-variable or a 0-variable for all j∈[2⁒t].

Thus, we have

limmβ†’βˆžlimΞ΅β†’0E⁑[cost⁒(Ο€NA)∣Xβˆ’m∈[βˆ’t,tβˆ’1]]limmβ†’βˆžlimΞ΅β†’0E⁑[cost⁒(Ο€)∣Xβˆ’m∈[βˆ’t,tβˆ’1]]=2⁒t+1t+1,

which is what we wanted to show. β—€

4 PTAS for the Unit-Cost Case

In this section, we show Theorem 2, which we restate here for convenience.

Theorem 2. [Restated, see original statement.]

There is a PTAS for computing the optimal non-adaptive policy for evaluating k-of-n functions in the unit-cost case.

In Section 4.1, we first reduce the task to get a PTAS to computing solution with certain properties for a β€œbounded” variant of the problem. Then, in Section 4.2, we solve this variant of the problem.

Throughout the section we let π⋆:=OPTNA⁒(f,c,p) the optimal non-adaptive policy. We also assume without loss of generality that 1/Ξ΅βˆˆβ„• and use OΡ⁒(β‹…) to suppress dependencies on Ξ΅ in O⁒(β‹…) notation.

4.1 Reduction to the Bounded Variant

In this subsection we will prove that the following lemma suffices to obtain a PTAS for our problem. The proof of the lemma is then given in the subsection after.

Lemma 6.

Given Ξ΅>0 and a,aβ€²βˆˆ[n] with a<aβ€², there is an algorithm that enumerates non-adaptive partial policies Ο€1,Ο€2,…, each stopping after aβ€² tests, in time nOΡ⁒(aβ€²/a) among which there is some Ο€j with

Pr⁑[cost⁒(Ο€j)β‰₯i]≀Pr⁑[(1+Ξ΅)⁒cost⁒(π⋆)β‰₯i]

for each i∈{a,a+1,…,aβ€²}.

We are particularly interested in the following consequence of the lemma.

Corollary 7.

Given Ξ΅>0 and a,aβ€²βˆˆ[n] with a<aβ€², there is an algorithm that finds in time nOΡ⁒(aβ€²/a) a non-adaptive partial policy Ο€ stopping after aβ€² tests and satisfying

βˆ‘i=aaβ€²βˆ’1Pr⁑[cost⁒(Ο€)β‰₯i]+aβ€²β‹…Pr⁑[cost⁒(Ο€)β‰₯aβ€²]β‰€βˆ‘i=aaβ€²βˆ’1Pr⁑[(1+Ξ΅)⁒cost⁒(π⋆)β‰₯i]+aβ€²β‹…Pr⁑[(1+Ξ΅)⁒cost⁒(π⋆)β‰₯aβ€²].

Proof.

Towards this, apply Lemma 6 and return the policy that minimizes the left-hand side. Note that the left-hand side for each solution can be computed in polynomial time using dynamic programming, where the table we compute contains for every i=1,2,…,n and every kβ€²=1,2,…,i the probability of having exactly kβ€² 1s after the ith test (see also description in [12, Section 7]). Since Ο€j (as in Lemma 6) satisfies the inequality, so does the minimizer. β—€

Using this we prove the main result.

Proof of Theorem 2 assuming Lemma 6.

Note that

E⁑[cost⁒(π⋆)]β‰₯βˆ‘i=1nPr⁑[(1+Ξ΅)⁒cost⁒(π⋆)∈[i,i+1)]β‹…i1+Ξ΅.

Thus,

(1+Ξ΅)⁒E⁑[cost⁒(π⋆)]β‰₯βˆ‘i=1nPr⁑[(1+Ξ΅)⁒cost⁒(π⋆)∈[i,i+1)]β‹…i=βˆ‘i=1nPr⁑[(1+Ξ΅)⁒cost⁒(π⋆)β‰₯i].

Let aj⁒(i)=21/Ξ΅β‹…j+i for each i=0,…,1/Ξ΅βˆ’1 and jβˆˆβ„•0. Observe that

{aj⁒(0)∣jβˆˆβ„•0},…,{aj⁒(1/Ξ΅βˆ’1)∣jβˆˆβ„•0}

forms a partition of {2i∣iβˆˆβ„•0}. We will show that there exists a partition class that β€œcontributes” only little to the cost of the optimum. Towards this, observe

βˆ‘i=01/Ξ΅βˆ’1βˆ‘jβˆˆβ„•0aj⁒(i)β‹…Pr⁑[(1+Ξ΅)⁒cost⁒(π⋆)β‰₯aj⁒(i)]=βˆ‘iβˆˆβ„•02iβ‹…Pr⁑[(1+Ξ΅)⁒cost⁒(π⋆)β‰₯2i]≀2β’βˆ‘i=1nPr⁑[(1+Ξ΅)⁒cost⁒(π⋆)β‰₯i]=2⁒(1+Ξ΅)⁒E⁑[cost⁒(π⋆)].

Thus, there exists some β„“ that contributes only a small fraction to the left-hand side, i.e.,

βˆ‘jβˆˆβ„•0aj⁒(β„“)β‹…Pr⁑[cost⁒(π⋆)β‰₯aj⁒(β„“)]≀2⁒Ρ⁒(1+Ξ΅)β‹…E⁑[cost⁒(π⋆)]. (2)

In the following we assume that β„“ is known to the algorithm. Formally, the algorithm runs for every possible choice of β„“, computes the expected cost of the resulting policy (again using dynamic programming [12, Section 7]) and outputs the one with the lowest expected cost.

For sake of brevity, write aj instead of aj⁒(β„“). Further, define a0=1, and let h be minimum such that ah+1β‰₯n. For j∈{0,…,h}, let Ο€j be the partial policy generated by applying Corollary 7 with a=aj and aβ€²=aj+1. We define the final policy Ο€ as Ο€0βˆ˜Ο€1βˆ˜β‹―βˆ˜Ο€h.

For some j∈{1,…,h} we consider how many tests from Ο€j are actually performed in Ο€. If cost⁒(Ο€jβˆ’1)<aj, then none of the tests of Ο€j are performed (except for duplicates appearing in Ο€0,…,Ο€jβˆ’1), since, by the end of Ο€jβˆ’1, Ο€ has already determined the function value. Otherwise, we may or may not perform tests from Ο€j (depending on Ο€0,…,Ο€jβˆ’2), but never more than

aj+βˆ‘i=aj+1aj+1βˆ’1𝟏cost⁒(Ο€j)β‰₯i.

By linearity of expectation, it follows that

E⁑[cost⁒(Ο€)] β‰€βˆ‘i=1a1βˆ’1Pr⁑[cost⁒(Ο€0)β‰₯i]
+βˆ‘j=1h[ajβ‹…Pr⁑[cost⁒(Ο€jβˆ’1)β‰₯aj]+βˆ‘i=aj+1aj+1βˆ’1Pr⁑[cost⁒(Ο€j)β‰₯i]]
β‰€βˆ‘j=0h[βˆ‘i=ajaj+1βˆ’1Pr⁑[cost⁒(Ο€j)β‰₯i]+aj+1β‹…Pr⁑[cost⁒(Ο€j)β‰₯aj+1]]
β‰€βˆ‘j=0h[βˆ‘i=ajaj+1βˆ’1Pr⁑[(1+Ξ΅)⁒cost⁒(π⋆)β‰₯i]+aj+1β‹…Pr⁑[(1+Ξ΅)⁒cost⁒(π⋆)β‰₯aj+1]]
≀(1+Ξ΅)⁒E⁑[cost⁒(π⋆)]+βˆ‘j=1hajβ‹…Pr⁑[(1+Ξ΅)⁒cost⁒(π⋆)β‰₯aj]
≀(1+Ξ΅)⁒E⁑[cost⁒(π⋆)]+2⁒(1+Ξ΅)⁒Ρ⋅E⁑[cost⁒(π⋆)]≀(1+4⁒Ρ)β‹…E⁑[cost⁒(π⋆)],

where we use the property guaranteed by Corollary 7 in the third step and Equation 2 in the fourth step. Since aj+1/aj≀21/Ξ΅ for all j, the running time is bounded by n2O⁒(1/Ξ΅). Scaling Ξ΅ with a factor of 1/4 reduces the approximation ratio to 1+Ξ΅ while preserving the running time above. β—€

4.2 Algorithm for the Bounded Variant

The goal of this subsection is to show Lemma 6, which will complete the proof of Theorem 2. Our algorithm will pick tests so as to dominate certain parts of the optimal solution. The notion of dominance is the following.

Let V,Vβ‹†βŠ†[n] with |V|β‰₯|V⋆|. For hβˆˆβ„•, denote by [βˆ’h]={n,nβˆ’1,…,nβˆ’h+1}. We say that V dominates V⋆ (written Vβͺ°V⋆) if, for any h∈[n],

  • β– 

    |V∩[h]|β‰₯|Vβ‹†βˆ©[h]| (called left dominance) and

  • β– 

    |V∩[βˆ’h]|β‰₯|Vβ‹†βˆ©[βˆ’h]| (called right dominance).

Equivalently, there exists an injection β„“:V⋆→V such that ℓ⁒(v)≀v for all v∈V⋆ (left dominance) and there exists an injection r:V⋆→V such that r⁒(v)β‰₯v for all v∈V⋆ (right dominance). Recall that the variables are sorted by their probabilities, so the injections above satisfy that pℓ⁒(v)≀pv and pr⁒(v)β‰₯pv.

Clearly, if |V|=|V⋆|, then Vβͺ°V⋆ implies V=V⋆. But if |V|>|V⋆|, then the sets can be different. For example, if V⋆ contains the middle third of [3⁒n] and V=[3⁒n]βˆ–V⋆, then Vβͺ°V⋆ and yet V and V⋆ are disjoint. It turns out that even without full knowledge of V⋆, but with an appropriately chosen small fraction of the elements (called milestones in the following) of V⋆, we can efficiently find a set V which is guaranteed to dominate V⋆ and does not contain many more elements.

We first show that dominance is a desirable property.

Lemma 8.

Let Ο€ and Ο€β€² be partial non-adaptive policies. Suppose that for some β„“,β„“β€²βˆˆ[n], the length-β„“β€² prefix of Ο€β€² dominates the length-β„“ prefix of Ο€. Then

Pr⁑[cost⁒(Ο€β€²)>β„“β€²]≀Pr⁑[cost⁒(Ο€)>β„“].

The lemma follows quite easily from the following lemma. We give a proof in the full version.

Lemma 9.

Let V,Vβ‹†βŠ†[n] be such that Vβͺ°V⋆. Then, for any β„“βˆˆ[|V⋆|] we have

Pr⁒[βˆ‘i∈Vxiβ‰₯β„“]β‰₯Pr⁒[βˆ‘i∈V⋆xiβ‰₯β„“]⁒ and ⁒Pr⁒[βˆ‘i∈V(1βˆ’xi)β‰₯β„“]β‰₯Pr⁒[βˆ‘i∈V⋆(1βˆ’xi)β‰₯β„“].

Proof.

We focus on showing the first inequality; the proof for the second inequality is symmetric. Let β„“βˆˆ[|V⋆|] be arbitrary. Since Vβͺ°V⋆, there exists an injective mapping f:V⋆→V such that pi≀pf⁒(i) for all i∈V⋆.

We couple XV⋆={xi∣i∈V⋆} and XV={xi∣i∈V} by demanding that xi=1 implies xf⁒(i)=1 for all i∈V⋆. (If f⁒(i)=i, this is a vacuous demand.) This is possible since pi≀pf⁒(i) for all i∈V⋆. Also note that XV⋆ is still independent and XV is still independent (but XV⋆βˆͺXV is not independent, unless V⋆=V); hence the inequality that is to be shown remains unaffected.

For all i∈V⋆, now define Ξ΄i:=xf⁒(i)βˆ’xi and notice that, by our coupling, Ξ΄i is non-negative. Thus,

Pr⁒[βˆ‘i∈Vxiβ‰₯β„“]β‰₯Pr⁒[βˆ‘i∈V⋆xf⁒(i)β‰₯β„“]=Pr⁒[βˆ‘i∈V⋆xi+Ξ΄iβ‰₯β„“]β‰₯Pr⁒[βˆ‘i∈V⋆xiβ‰₯β„“],

where we use injectivity of f in the first step, the definition of Ξ΄i in the second step, and non-negativity of Ξ΄i in the third step. The claim follows. β—€

Recall that we are not only interested in a single inequality of the type that Lemma 8 states; Lemma 6 demands multiple such inequalities. To this end, we do not only seek to dominate a single set. It will, however, be sufficient to think of the optimal solution in terms of a sequence of b∈OΡ⁒(aβ€²/a) disjoint sets (β€œbuckets”) so that the order within each bucket does not matter. Then, we aim to find another sequence of disjoint sets, also of length b, such that we have the aforementioned dominance property for each two corresponding prefixes of the two sequences.

Formally, let (V1⋆,V2⋆,…,Vb⋆) be a b-tuple of disjoint subsets of [n] with |Vi⋆|β‰₯1/Ξ΅ for all i∈[b]. We are going to enumerate a number of b-tuples of the form (V1,V2,…,Vb) with the following properties:

  1. (i)

    For all b-tuples in the enumeration, V1,…,Vb are disjoint subsets of [n],

  2. (ii)

    For all b-tuples in the enumeration, |Vi|≀(1+2⁒Ρ)⁒|Vi⋆| for all i∈[b], and

  3. (iii)

    For at least one b-tuple in the enumeration, it holds that ⋃iβ€²=1iViβ€²βͺ°β‹ƒiβ€²=1iVi′⋆ for all i∈[b].

We first show that this will indeed to lead to inequalities akin to Lemma 6 (if we require certain sizes of Vi⋆ for all i∈[b]).

Lemma 10.

Let a and aβ€² be positive integers with 2⁒(1+Ξ΅)2/Ρ≀a<a′≀n, and let b be another positive integer. Furthermore:

  • β– 

    Let (V1⋆,V2⋆,…,Vb⋆) be a b-tuple of disjoint subsets of [n] such that π⋆=Ο€1β‹†βˆ˜β‹―βˆ˜Ο€bβ‹†βˆ˜Ο€b+1⋆, Vi⋆=set⁒(Ο€i⋆) for all i∈[b], |V1⋆|=⌊(aβˆ’1)/(1+2⁒Ρ)βŒ‹, and |Vi⋆|β‰€βŒˆΞ΅β’|V1⋆|βŒ‰ for all i∈[b]βˆ–{1}.

  • β– 

    Let (V1,V2,…,Vb) be a b-tuple of disjoint subsets of [n] with

    ⋃iβ€²=1iViβ€²βͺ°β‹ƒiβ€²=1iVi′⋆

    and |Vi|≀(1+2⁒Ρ)⁒|Vi⋆| for all i∈[b]. Also let Ο€=Ο€1βˆ˜β‹―βˆ˜Ο€b be a partial policy, where Ο€i is an arbitrary partial policy with set⁒(Ο€i)=Vi for all i∈[b].

Then

Pr⁑[cost⁒(Ο€)β‰₯β„“]≀Pr⁑[(1+2⁒Ρ)3⁒cost⁒(π⋆)β‰₯β„“]

for all β„“βˆˆ{a,a+1,…,aβ€²}.

Proof.

Consider some β„“βˆˆ{a,a+1,…,aβ€²}.

Let i≀b be the largest integer such that βˆ‘iβ€²=1i|Viβ€²|β‰€β„“βˆ’1 and let β„“β€²=βˆ‘iβ€²=1i|Viβ€²|. We observe that

|V1|≀(1+2⁒Ρ)⁒|V1⋆|≀aβˆ’1β‰€β„“βˆ’1, (3)

where the second inequality follows from the choice of |V1⋆|=⌊(aβˆ’1)/(1+2⁒Ρ)βŒ‹. Thus, iβ‰₯1. Since |Vi⋆|β‰€βŒˆΞ΅β’|V1⋆|βŒ‰ for iβ‰₯2 and as i is maximal, we have

β„“β€² β‰₯β„“βˆ’1βˆ’βŒˆΞ΅β’|V1⋆|βŒ‰
>β„“βˆ’1βˆ’Ξ΅β’|V1⋆|βˆ’1
β‰₯β„“βˆ’1βˆ’(aβˆ’1)⁒Ρ1+2β’Ξ΅βˆ’1
β‰₯β„“βˆ’1βˆ’(β„“βˆ’1)⁒Ρ1+2β’Ξ΅βˆ’1
=β„“βˆ’11+2β’Ξ΅βˆ’1
>β„“1+2β’Ξ΅βˆ’2
β‰₯β„“(1+2⁒Ρ)2, (4)

where the third inequality follows from Equation 3 and the last inequality holds as β„“β‰₯aβ‰₯2⁒(1+Ξ΅)2/Ξ΅.

Let ℓ⋆=βˆ‘iβ€²=1i|Vi′⋆|. Using that Pr⁑[cost⁒(Ο€β€²)β‰₯x] does not increase as x increases for any partial policy Ο€β€², we obtain

Pr⁑[cost⁒(Ο€)β‰₯β„“] ≀Pr⁑[cost⁒(Ο€)>β„“βˆ’1]
≀Pr⁑[cost⁒(Ο€)>β„“β€²]
≀Pr⁑[cost⁒(π⋆)>ℓ⋆]
≀Pr⁑[cost⁒(π⋆)>β„“β€²/(1+2⁒Ρ)]
≀Pr⁑[cost⁒(π⋆)β‰₯β„“/(1+2⁒Ρ)3].

Indeed, the second inequality follows from the definition of β„“β€². The third inequality follows from ⋃iβ€²=1iViβ€²βͺ°β‹ƒiβ€²=1iVi′⋆ and Lemma 8. The fourth inequality follows from ℓ⋆β‰₯β„“β€²/(1+2⁒Ρ), which is due to |Vi|≀|Vi⋆|/(1+2⁒Ρ) for all i∈[b]. Finally, the last inequality follows from Equation 4. β—€

It remains to show that we can indeed enumerate b-tuples with the desired properties (i)–(iii). Towards this, consider some (V1⋆,V2⋆,…,Vb⋆), i∈[b], and j∈[1/Ξ΅βˆ’1]. We denote by m⁒(Vi⋆,j) the (⌊j⁒Ρ⁒|Vi⋆|βŒ‹)-th smallest element in Vi⋆. We call m⁒(Vi⋆,j) the j-th milestone of Vi⋆. (These milestones will later be β€œguessed.”)

We present an algorithm (Algorithm 1) that receives the sizes |V1⋆|,…,|Vb⋆| as well as such milestones as input and computes, when the milestones are correct, a b-tuple (V1,V2,…,Vb) with the desired properties (in particular (iii)).

The algorithm does the following for each i∈[b]. There is a counter c that is Ρ⁒|Vi⋆| initially. The algorithm first does a forward pass over the elements (the forward loop, from line 4 to 9), greedily adding available elements to Vi as long as the value of c is at least 1. During this pass, we increment c by Ρ⁒|Vi⋆| whenever we encounter a milestone. The forward loop alone is enough to guarantee left dominance. Note that c takes non-integer values if Ρ⁒|Vi⋆| is not integer.

Then, the algorithm increments the counter by ⌈Ρ⁒|Vi⋆|βŒ‰ and starts the backward loop (lines 11 to 14), which does a backward pass over the elements, greedily adding available elements to Vi as long as the counter c is at least 1. This is intuitively what ensures right dominance.

Algorithm 1 Achieving dominance for all bucket prefixes with only slightly more tests than the optimal solution.

We illustrate this algorithm in Figure 1. The following lemma shows that Algorithm 1 fulfills its purpose.

(a) An example set V1⋆ indicated with shade. Milestones for Ξ΅=1/4 indicated with darker shade.
(b) The set V1 that Algorithm 1 produces given the shaded milestones.
Figure 1: Example of output generated by Algorithm 1 for a single iteration of the main loop.
Lemma 11.

Let (V1⋆,V2⋆,…,Vb⋆) be any b-tuple of disjoint subsets of [n]. The output (V1,V2,…,Vb) of Algorithm 1 when given |Vi⋆|β‰₯1/Ξ΅ for i∈[b], and m⁒(Vi⋆,j) for i∈[b] and j∈[1/Ξ΅βˆ’1] satisfies

⋃iβ€²=1iViβ€²βͺ°β‹ƒiβ€²=1iVi′⋆

and |Vi|≀(1+2⁒Ρ)⁒|Vi⋆| for all i∈[b].

Proof.

We start by observing that |Vi|≀(1+2⁒Ρ)⁒|Vi⋆| holds for all i∈[b] as at most

Ρ⁒|Vi⋆|+(1Ξ΅βˆ’1)⁒Ρ⁒|Vi⋆|+⌈Ρ⁒|Vi⋆|βŒ‰β‰€(1+Ξ΅)⁒|Vi⋆|+1≀(1+2⁒Ρ)⁒|Vi⋆|

elements are added to Vi, where the last inequality holds as |Vi|β‰₯1/Ξ΅.

We now show that ⋃iβ€²=1iViβ€²βͺ°β‹ƒiβ€²=1iVi′⋆ by induction on i. Denote V0=V0⋆=βˆ… such that the base case V0βͺ°V0⋆ is trivial. Let iβ‰₯1 and suppose that ⋃iβ€²=0iβˆ’1Viβ€²βͺ°β‹ƒiβ€²=0iβˆ’1Vi′⋆. Let V=⋃iβ€²=0iViβ€² and let V⋆=⋃iβ€²=0iVi⋆. We must show that Vβͺ°V⋆. We claim the following.

Claim 12.

For any h∈[n]βˆ–V, we have

  1. (i)

    |Vi∩[h]|β‰₯|Viβ‹†βˆ©[h]| and

  2. (ii)

    |Vi∩{n,nβˆ’1,…,h}]|β‰₯|Viβ‹†βˆ©{n,nβˆ’1,…,h}|

Proof.

Consider any h∈[n]βˆ–V. Let

M=|{j∈[1/Ξ΅βˆ’1]∣m⁒(Vi⋆,j)<h}|

be the number of milestones smaller than h. Note that h itself cannot be a milestone as any milestone is added to Vi on line 8 after c is incremented by at least 1 on line 6.

We start by observing that

⌊M⁒Ρ⁒|Vi⋆|βŒ‹β‰€|Viβ‹†βˆ©[hβˆ’1]|≀|Viβ‹†βˆ©[h]|β‰€βŒŠ(M+1)⁒Ρ⁒|Vi⋆|βŒ‹, (5)

which follows directly from the definition of milestones and the fact that h is not a milestone. See Figure 2.

Figure 2: Illustration of the setup in the proof of Claim 12. Shaded boxes indicate elements in the corresponding set.

To show (i), consider the iteration of the forward loop where f=h. As hβˆ‰V, h was not added to Vi on line 8, implying that c<1 on line 7. As c is initially Ρ⁒|Vi⋆| and was incremented by M⁒Ρ⁒|Vi⋆| before this iteration, we must have

|Vi∩[h]|=⌊(M+1)⁒Ρ⁒|Vi⋆|βŒ‹β‰₯|Viβ‹†βˆ©[h]|,

where the last inequality follows from Equation 5.

Define hβ€²=nβˆ’h+1 such that [βˆ’hβ€²]={n,nβˆ’1,…,h}. To show (ii), consider the iteration of the backward loop where f=h. As hβˆ‰V, h was not added to Vi on line 13, implying that c<1 in this iteration. In fact, we must have c=0 as the fractional increments of c sum to Ρ⁒|Vi⋆|+(1/Ξ΅βˆ’1)⁒Ρ⁒|Vi⋆|=|Vi⋆| and c is only ever decremented by 1. Since c was incremented by (1/Ξ΅βˆ’1βˆ’M)⁒Ρ⁒|Vi⋆|+⌈Ρ⁒|Vi⋆|βŒ‰ between the iteration of the forward loop where f=h and the iteration of the backward loop where f=h, we must have

|Vi∩[βˆ’hβ€²]|β‰₯(1/Ξ΅βˆ’1βˆ’M)⁒Ρ⁒|Vi⋆|+⌈Ρ⁒|Vi⋆|βŒ‰

We see that also

|Viβ‹†βˆ©[βˆ’hβ€²]|=|Vi⋆|βˆ’|Viβ‹†βˆ©[hβˆ’1]|≀|Vi⋆|βˆ’βŒŠM⁒Ρ⁒|Vi⋆|βŒ‹

where we use Equation 5 in the second inequality. Subtracting the above two inequalities we get

|Viβ‹†βˆ©[βˆ’hβ€²]|βˆ’|Vi∩[βˆ’hβ€²]| ≀|Vi⋆|βˆ’βŒŠM⁒Ρ⁒|Vi⋆|βŒ‹βˆ’(1/Ξ΅βˆ’1βˆ’M)⁒Ρ⁒|Vi⋆|βˆ’βŒˆΞ΅β’|Vi⋆|βŒ‰
=(M+1)⁒Ρ⁒|Vi⋆|βˆ’βŒˆΞ΅β’|Vi⋆|βŒ‰βˆ’βŒŠM⁒Ρ⁒|Vi⋆|βŒ‹
<1,

from which it follows that |Viβ‹†βˆ©[βˆ’hβ€²]|βˆ’|Vi∩[βˆ’hβ€²]|≀0 as both terms are integers. ⊲

We return to the proof of the lemma. Suppose that |V∩[h]|<|Vβˆ—βˆ©[h]| for some h∈[n] and let h be minimal with this property. By the minimality of h, we must have hβˆ‰VβŠ‡Vi. By the induction hypothesis and Claim 12,

|V∩[k]| =|(Vβˆ–Vi)∩[h]|+|Vi∩[h]|
β‰₯|(Vβ‹†βˆ–Vi⋆)∩[h]|+|Viβ‹†βˆ©[h]|
=|Vβ‹†βˆ©[h]|,

which is a contradiction.

Suppose that |V∩[βˆ’hβ€²]|<|Vβˆ—βˆ©[βˆ’hβ€²]| for some hβ€²βˆˆ[n] and let hβ€² be minimal with this property. Let k=nβˆ’hβ€²+1. Then hβˆ‰V. By the induction hypothesis and Claim 12,

|V∩[βˆ’hβ€²]| =|(Vβˆ–Vi)∩[βˆ’hβ€²]|+|Vi∩[βˆ’hβ€²]|
β‰₯|(Vβ‹†βˆ–Vi⋆)∩[βˆ’hβ€²]|+|Viβ‹†βˆ©[βˆ’hβ€²]|
=|Vβ‹†βˆ©[βˆ’hβ€²]|,

which is again a contradiction. β—€

Lemma 6 now follows relatively directly by combining the last two lemmas with full enumeration.

Proof of Lemma 6.

We need to distinguish a few cases, to cover cases in which we cannot apply Lemma 11 and Lemma 10:

  1. Case 1:

    a<4⁒(1+Ξ΅)/Ξ΅2+1. In this case we can in time nOΡ⁒(aβ€²/a) fully enumerate all partial policies of length aβ€², showing the claim, even without the 1+Ξ΅ factor.

  2. Case 2:

    aβ‰₯4⁒(1+Ξ΅)/Ξ΅2+1. This implies that aβ‰₯2⁒(1+Ξ΅)2/Ξ΅ (using 1/Ξ΅βˆˆβ„•), which is needed to apply Lemma 10. The same assumption allows us to define |V1⋆|=⌊(aβˆ’1)/(1+2⁒Ρ)βŒ‹ and get that Ρ⁒|V1⋆|β‰₯2/Ξ΅.

    1. Case 2a:

      aβ€²βˆ’βŒŠ(aβˆ’1)/(1+2⁒Ρ)βŒ‹<2/Ξ΅. We will run into trouble defining bucket sizes so as to apply Lemma 11. Since a may be too large, we cannot simply enumerate all partial policies of length aβ€². We define b=2 and |V2⋆|=aβ€²βˆ’|V1⋆|. We apply full enumeration to obtain m⁒(V1⋆,j) for all j∈[1/Ξ΅βˆ’1]. We obtain V1 by Algorithm 1 and V2 by full enumeration, in total time nOΡ⁒(1). Then, for the correct elements from the enumerations, Lemma 11 guarantees that also the dominance condition needed to apply Lemma 10 is fulfilled.

    2. Case 2b:

      aβ€²βˆ’βŒŠ(aβˆ’1)/(1+2⁒Ρ)βŒ‹β‰₯2/Ξ΅. We define |V2⋆|,…,|Vb⋆| in the following way: Start with a counter with value equal to the total size of |V2⋆|,…,|Vb⋆|, which, by definition of |V1⋆|, is aβ€²βˆ’βŒŠ(aβˆ’1)/(1+2⁒Ρ)βŒ‹β‰₯2/Ξ΅. Open a new bucket of size 1/Ξ΅ and decrease the counter by 1/Ξ΅ until the value of the counter drops to 2/Ξ΅ or less. Define the final (b-th) bucket to have size of the current value of the counter. This way, 1/Ρ≀|Vi⋆|≀2/Ρ≀Ρ⁒|V1| for all i∈[b], and b∈OΡ⁒(aβ€²/a). We may thus enumerate m⁒(Vi⋆,j) for all i∈[b] and j∈[1/Ξ΅βˆ’1], in time nOΡ⁒(aβ€²/a), and apply Lemma 11 to each element in the enumeration. For the correct element from the enumeration, we may then also apply Lemma 10.

Note that, in Cases 2a and 2b, we need to scale down Ξ΅ by a constant to obtain the necessary guarantee from the application of Lemma 10. β—€

5 Conclusion

First, it remains as an open question whether there also exists a PTAS for the arbitrary-cost case. It seems plausible that one can use standard techniques to get the number of relevant cost classes per bucket down to a logarithmic number and to then use a similar approach as described in Section 4.2 for each cost class, which would result in a QPTAS. It is unclear to us whether this approach can be modified to obtain a PTAS.

Second, recall that it is not known whether computing the optimal non-adaptive policy for SBFE of k-of-n functions is NP-hard, even in the arbitrary-cost case. Although there are many problems in stochastic combinatorial optimization with this status, and it is common to develop approximation algorithms for them, that fact may be particularly intriguing for this fundamental problem.

References

  • [1] Sarah R Allen, Lisa Hellerstein, Devorah Kletenik, and TonguΓ§ ÜnlΓΌyurt. Evaluation of monotone DNF formulas. Algorithmica, 77(3):661–685, 2017. doi:10.1007/S00453-015-0092-9.
  • [2] Yosi Ben-Dov. Optimal testing procedure for special structures of coherent systems. Management Science, 27(12):1410–1420, 1981.
  • [3] Hedyeh Beyhaghi and Linda Cai. Pandora’s problem with nonobligatory inspection: Optimal structure and a PTAS. In ACM Symposium on Theory of Computing (STOC), pages 803–816, 2023. doi:10.1145/3564246.3585217.
  • [4] Yubing Cui and Viswanath Nagarajan. Minimum cost adaptive submodular cover. In Symposium on Simplicity in Algorithms (SOSA), pages 12–27, 2023. doi:10.1137/1.9781611977585.CH2.
  • [5] Brian C. Dean, Michel X. Goemans, and Jan VondrΓ‘k. Approximating the stochastic knapsack problem: The benefit of adaptivity. Math. Oper. Res., 33(4):945–964, 2008. doi:10.1287/MOOR.1080.0330.
  • [6] Amol Deshpande, Lisa Hellerstein, and Devorah Kletenik. Approximation algorithms for stochastic submodular set cover with applications to Boolean function evaluation and min-knapsack. ACM Transactions on Algorithms (TALG), 12(3):1–28, 2016. doi:10.1145/2876506.
  • [7] Alina Ene, Viswanath Nagarajan, and Rishi Saket. Approximation algorithms for stochastic k-TSP. In Conference on Foundations of Software Technology and Theoretical Computer Science (FSTTCS), pages 27:27–27:14, 2017. doi:10.4230/LIPICS.FSTTCS.2017.27.
  • [8] Luoyi Fu, Xinzhe Fu, Zhiying Xu, Qianyang Peng, Xinbing Wang, and Songwu Lu. Determining source–destination connectivity in uncertain networks: Modeling and solutions. IEEE/ACM Transactions on Networking, 25(6):3237–3252, 2017. doi:10.1109/TNET.2017.2725905.
  • [9] Rohan Ghuge, Anupam Gupta, and Viswanath Nagarajan. Non-adaptive stochastic score classification and explainable halfspace evaluation. In International Conference on Integer Programming and Combinatorial Optimization (IPCO), pages 277–290, 2022. doi:10.1007/978-3-031-06901-7_21.
  • [10] Dimitrios Gkenosis, Nathaniel Grammel, Lisa Hellerstein, and Devorah Kletenik. The stochastic score classification problem. In European Symposium on Algorithms (ESA), pages 36:1–36:14, 2018. doi:10.4230/LIPICS.ESA.2018.36.
  • [11] Dimitrios Gkenosis, Nathaniel Grammel, Lisa Hellerstein, and Devorah Kletenik. The stochastic Boolean function evaluation problem for symmetric Boolean functions. Discrete Applied Mathematics, 309:269–277, 2022. doi:10.1016/J.DAM.2021.12.001.
  • [12] Nathaniel Grammel, Lisa Hellerstein, Devorah Kletenik, and Naifeng Liu. Algorithms for the unit-cost stochastic score classification problem. Algorithmica, 84(10):3054–3074, 2022. doi:10.1007/S00453-022-00982-4.
  • [13] Mingyu Guo, Jialiang Li, Aneta Neumann, Frank Neumann, and Hung X. Nguyen. Limited query graph connectivity test. In AAAI Conference on Artificial Intelligence (AAAI), pages 20718–20725, 2024. doi:10.1609/AAAI.V38I18.30059.
  • [14] Lisa Hellerstein, Devorah Kletenik, Naifeng Liu, and R. Teal Witter. Adaptivity Gaps for the Stochastic Boolean Function Evaluation Problem. In Workshop on Approximation and Online Algorithms (WAOA), pages 190–210, 2022. doi:10.1007/978-3-031-18367-6_10.
  • [15] Lisa Hellerstein, Devorah Kletenik, and Srinivasan Parthasarathy. A tight bound for stochastic submodular cover. Journal of Artificial Intelligence Research, 71:347–370, 2021. doi:10.1613/JAIR.1.12368.
  • [16] Lisa Hellerstein, Naifeng Liu, and Kevin Schewior. Quickly determining who won an election. In Proceedings of the 15th Innovations in Theoretical Computer Science Conference (ITCS), pages 61:1–61:14, 2024. doi:10.4230/LIPICS.ITCS.2024.61.
  • [17] Sungjin Im, Viswanath Nagarajan, and Ruben van der Zwaan. Minimum latency submodular cover. ACM Transactions on Algorithms, 13(1):13:1–13:28, 2016. doi:10.1145/2987751.
  • [18] Haotian Jiang, Jian Li, Daogao Liu, and Sahil Singla. Algorithms and adaptivity gaps for stochastic k-TSP. In Innovations in Theoretical Computer Science Conference (ITCS), pages 45:1–45:25, 2020. doi:10.4230/LIPICS.ITCS.2020.45.
  • [19] Haim Kaplan, Eyal Kushilevitz, and Yishay Mansour. Learning with attribute costs. In ACM Symposium on the Theory of Computing (STOC), pages 356–365, 2005. doi:10.1145/1060590.1060644.
  • [20] Naifeng Liu. Two 6-approximation algorithms for the stochastic score classification problem. CoRR, abs/2212.02370, 2022. doi:10.48550/arXiv.2212.02370.
  • [21] Benedikt M. Plank and Kevin Schewior. Simple algorithms for stochastic score classification with small approximation ratios. SIAM Journal on Discrete Mathematics, 38(3):2069–2088, 2024. doi:10.1137/22M1523492.
  • [22] Salam Salloum and Melvin Breuer. An optimum testing algorithm for some symmetric coherent systems. Journal of Mathematical Analysis and Applications, 101(1):170–194, 1984.
  • [23] Danny Segev and Sahil Singla. Efficient approximation schemes for stochastic probing and prophet problems. In ACM Conference on Economics and Computation (EC), pages 793–794, 2021. doi:10.1145/3465456.3467614.
  • [24] TonguΓ§ ÜnlΓΌyurt. Sequential testing of complex systems: a review. Discrete Applied Mathematics, 142(1-3):189–205, 2004. doi:10.1016/J.DAM.2002.08.001.