Abstract 1 Introduction 2 Algorithm for Unit Costs 3 Algorithm for General Costs References Appendix A Multiplicative Precision Appendix B Bad Example for Competitive Ratio

Identifying Approximate Minimizers Under Stochastic Uncertainity

Hessa Al-Thani ORCID Department of Industrial and Operations Engineering, University of Michigan, Ann Arbor, MI, USA Viswanath Nagarajan ORCID Department of Industrial and Operations Engineering, University of Michigan, Ann Arbor, MI, USA
Abstract

We study a fundamental stochastic selection problem involving n independent random variables, each of which can be queried at some cost. Given a tolerance level δ, the goal is to find a δ-approximately minimum (or maximum) value over all the random variables, at minimum expected cost. A solution to this problem is an adaptive sequence of queries, where the choice of the next query may depend on previously-observed values. Two variants arise, depending on whether the goal is to find a δ-minimum value or a δ-minimizer. When all query costs are uniform, we provide a 4-approximation algorithm for both variants. When query costs are non-uniform, we provide a 5.83-approximation algorithm for the δ-minimum value and a 7.47-approximation for the δ-minimizer. All our algorithms rely on non-adaptive policies (that perform a fixed sequence of queries), so we also upper bound the corresponding “adaptivity” gaps. Our analysis relates the stopping probabilities in the algorithm and optimal policies, where a key step is in proving and using certain stochastic dominance properties.

Keywords and phrases:
Approximation algorithms, stochastic optimization, selection problem
Category:
Track A: Algorithms, Complexity and Games
Funding:
Hessa Al-Thani: This publication was made possible by the Graduate Sponsorship Research Award from the Qatar Research and Development Institute. The findings herein reflect the work, and are solely the responsibility, of the authors.
Viswanath Nagarajan: Research supported in part by NSF grant CCF-2418495.
Copyright and License:
[Uncaptioned image] © Hessa Al-Thani and Viswanath Nagarajan; licensed under Creative Commons License CC-BY 4.0
2012 ACM Subject Classification:
Theory of computation Stochastic approximation
; Theory of computation Discrete optimization
Related Version:
Full Version: http://arxiv.org/abs/2504.17019 [2]
Editors:
Keren Censor-Hillel, Fabrizio Grandoni, Joël Ouaknine, and Gabriele Puppis

1 Introduction

We study a natural stochastic selection problem that involves querying a set of random variables so as to identify their minimum (or maximum) value within a desired precision. Consider a car manufacturer who wants to chose one design from n options so as to optimize some attribute (e.g., maximum velocity or energy efficiency). Each option i corresponds to an attribute value Xi which is uncertain and drawn from a known probability distribution. It is possible to determine the exact value of Xi by further testing – but this incurs some cost ci. Identifying the exact minimum (or maximum) value among the Xis might be too expensive. Instead, our goal is to identify an approximately minimum (or maximum) value, within a prescribed tolerance level. For example, we might be satisfied with a value (and corresponding option) that is within 10% of the true minimum. The objective is to minimize the expected cost. In this paper, we provide the first constant-factor approximation algorithm for this problem.

Our problem is related to two lines of work: stochastic combinatorial optimization and optimization under explorable uncertainty. In stochastic combinatorial optimization, a solution makes selections incrementally and adaptively (i.e., the next selection can depend on previously observed random outcomes). An optimal solution here may even require exponential space to describe. Nevertheless, there has been much recent success in obtaining (efficient) approximation algorithms for such problems, see e.g., [7, 14, 5, 15, 12, 19, 20, 17, 18]. Optimization problems under explorable uncertainty involve querying values drawn from known intervals in order to identify a minimizer. Typically, these results focus on the competitive ratio, which relates the algorithm’s (expected) query cost to the optimum query-cost in hindsight, see e.g., [21, 6, 10, 9, 22, 8, 4, 23]. In particular, for the problem of finding an exact minimizer among n intervals, [21] obtained a 2-competitive algorithm in the adversarial setting and [6] obtained a 1.45-approximation algorithm in the stochastic setting. The problem we study is a significant generalization of the stochastic exact minimizer problem [6].

1.1 Problem Definition

In the stochastic minimum query (𝖲𝖬𝖰) problem, there are n independent discrete random variables X1,,Xn that lie in intervals I1,,In respectively. The random variables (r.v.s) may be negative. We assume that each interval is bounded and closed, i.e., Ij=[j,rj] for each j[n]. We also assume (without loss of generality) that each r.v. has non-zero probability at the endpoints of its interval, i.e., Pr[Xj=j]>0 and Pr[Xj=rj]>0 for each j[n].111Otherwise, we can just work with a smaller interval representing the same r.v. We will use the terms random variable (r.v.) and interval interchangeably. The exact value of any r.v. Xj can only be determined by querying it, which incurs some cost cj0. Additionally, we are given a “precision” value δ0, where the goal is to identify the minimum value over all r.v.s up to an additive precision of δ. Formally, if 𝖬𝖨𝖭=minj=1nXj then we want to find a deterministic value 𝖵𝖠𝖫 such that 𝖬𝖨𝖭𝖵𝖠𝖫𝖬𝖨𝖭+δ. Such a value 𝖵𝖠𝖫 is called a δ-minimum value. The objective in 𝖲𝖬𝖰 is to minimize the expected cost of the queried intervals. Note that it may be sufficient to probe only a (small) subset of intervals before stopping.

We also consider a related, but harder, problem where the goal is to identify some δ-minimizer i[n], i.e., an interval that satisfies Xi𝖬𝖨𝖭+δ. We refer to this problem as stochastic minimum query for identification (𝖲𝖬𝖰𝖨). If a δ-minimum value is found then it also provides a δ-minimizer (see §1.4). However, the converse is not true. So, an 𝖲𝖬𝖰𝖨 solution may return an un-queried a δ-minimizer i without determining a δ-minimum value.

Although our formulation above uses additive precision (we aim to find a value that is at most 𝖬𝖨𝖭+δ), we can also handle multiplicative precision where the goal is to find a value that is at most α𝖬𝖨𝖭. This just requires a simple logarithmic transformation; see Appendix A. We can also handle the goal of finding the maximum value by working with negated r.v.s {Xi}i=1n.

Throughout, we use N:=[n]={1,2,,n} to denote the index set of the r.v.s.

Adaptive and Non-adaptive policies.

Any solution to 𝖲𝖬𝖰 involves querying r.v.s sequentially until a δ-minimum value is found. In general, the sequence of queries may depend on the realizations of previously queried r.v.s. We refer to such solutions as adaptive policies. Formally, such a solution can be described as a decision tree where each node corresponds to the next r.v. to query and the branches out of a node represent the realization of the queried r.v. Non-adaptive policies are a special class of solutions where the sequence of queries is fixed upfront: the policy then performs queries in this order until a δ-minimum value is found. A central notion in stochastic optimization is the adaptivity gap [7], which is the worst-case ratio between the optimal non-adaptive value and the optimal adaptive value. All our algorithms produce non-adaptive policies and hence also bound the adaptivity gap.

1.2 Results

Our first result is on the 𝖲𝖬𝖰 problem with unit costs, for which we provide a 4-approximation algorithm. Moreover, we achieve this result via a non-adaptive policy, which also proves an upper bound of 4 on the adaptivity gap. This algorithm relies on combining two natural policies. The first policy simply queries the r.v. with the smallest left-endpoint. The second policy queries the r.v. that maximizes the probability of stopping in the very next step. When used in isolation, both these policies have unbounded approximation ratios. However, interleaving the two policies leads to a constant-factor approximation algorithm.

We also consider the (harder) unit-cost 𝖲𝖬𝖰𝖨 problem and show that the same policy leads to a 4-approximation algorithm: the only change is in the criterion to stop, which is now more relaxed. While the algorithm is the same as 𝖲𝖬𝖰, the analysis for 𝖲𝖬𝖰𝖨 is significantly more complex due to the new stopping criterion, which allows us to infer a δ-minimizer i even when it has not been queried. Specifically, we prove a stochastic dominance property between r.v.s in our algorithm and the optimum (conditioned on the 𝖲𝖬𝖰 stopping criterion not occurring), and use this in relating the 𝖲𝖬𝖰𝖨 stopping-probability in the algorithm and the optimum.

Our next result is for the 𝖲𝖬𝖰 problem with non-uniform costs. We obtain a constant-factor approximation again, with a slightly worse ratio of 5.83. This is based on combining ideas from the unit-cost algorithm with a “power-of-two” approach. In particular, the algorithm proceeds in several iterations, where the ith iteration incurs cost roughly 2i. In each iteration i, the algorithm selects a subset of r.v.s with cost O(2i) based on the following two criteria (i) smallest left-endpoint and (ii) maximum probability of stopping in one step. In order to select the r.v.s for criterion (ii) we need to use a PTAS for an appropriate version of the knapsack problem.

Finally, we consider the 𝖲𝖬𝖰𝖨 problem with non-uniform costs. Directly using the 𝖲𝖬𝖰 algorithm for 𝖲𝖬𝖰𝖨 (as in the unit-cost case) does not work here: it leads to a poor approximation ratio. However, a modification of the 𝖲𝖬𝖰 algorithm works. Specifically, we modify step (i) above: instead of just selecting a prefix of intervals with the smallest left-endpoints, we select an “almost prefix” set by skipping some expensive intervals. We show that this approach leads to an approximation ratio of 7.47, which is slightly worse than what we obtain for 𝖲𝖬𝖰. The analysis combines aspects of unit-cost 𝖲𝖬𝖰𝖨 and 𝖲𝖬𝖰 with non-uniform costs.

1.3 Related Work

Computing an approximately minimum or maximum value by querying a set of random variables is a central question in stochastic optimization. Most of the prior works on this topic have focused on budgeted variants. Here, one wants to select a subset of queries of total cost within some budget so as to maximize or minimize the value among the queried r.v.s. The results for the minimization and maximization versions are drastically different. A 11e approximation algorithm for the budgeted max-value problem follows from results on stochastic submodular maximization [3]; more complex “budget” constraints can also be handled in this setting [1, 16]. These results also bound the adaptivity gap. In addition, PTASes are known for non-adaptive and adaptive versions of budgeted max-value [11, 24]. For the budgeted min-value problem, it is known that the adaptivity gap is unbounded and results for the non-adaptive and adaptive versions are based on entirely different techniques. [13] obtained a bi-criteria approximation algorithm for the non-adaptive problem (the queried subset must be fixed upfront) that achieves a 1+ϵ approximation to the optimal value while exceeding the budget by at most an O(loglogm) factor, where each r.v. takes an integer value in the range {0,1,,m}. Subsequently, [26] studied the adaptive setting (the queried subset may depend on observed realizations) and obtained a 4-approximation while exceeding the budget by at most an O(loglogm) factor. In contrast to these results, the goal in 𝖲𝖬𝖰 is to achieve a value close to the true minimum/maximum taken over all random variables X1,X2,,Xn (not just the queried ones). Moreover, we want to find an approximately min/max value with probability one, as opposed to optimizing the expected min/max value.

A different formulation of the minimum-element problem is studied in [25]: this combines the query-cost and the value of the minimum-queried element into a single objective. They obtain an exact algorithm for this setting, which also extends to a wider class of constrained problems.

Closely related to our work, [6] studied the 𝖲𝖬𝖰𝖨 problem with exact precision, i.e., δ=0. In particular, their goal is to identify an interval that is an exact minimizer. [6] obtained a 1.45-approximation ratio for general query costs. The 𝖲𝖬𝖰𝖨 problem that we study allows for arbitrary precision δ, and is significantly more complex than the setting in [6]. One indication of the difficulty of handling arbitrary δ is that the simpler 𝖲𝖬𝖰 problem with δ=0 (where we want to find the exact minimum value) admits a straightforward exact algorithm that queries by increasing left-endpoint; however, this algorithm has an unbounded ratio for 𝖲𝖬𝖰 with arbitrary δ (see §2 for an example).

As mentioned earlier, the 𝖲𝖬𝖰 problem is also related to optimization problems under explorable uncertainty. Apart from the minimum-value problem [21], various other problems like computing the median [10], minimum spanning tree [9, 22] and set selection [8, 4, 23] have been studied in this setting. The key difference from our work is that these results focus on the competitive ratio. In contrast, we compare to the optimal policy that is limited in the same manner as the algorithm. We note that there is an Ω~(n) lower bound on the competitive ratio for 𝖲𝖬𝖰 and 𝖲𝖬𝖰𝖨; see Appendix B. Our results show that much better (constant) approximation ratios are achievable for 𝖲𝖬𝖰 and 𝖲𝖬𝖰𝖨 in the stochastic setting, relative to an optimal policy.

1.4 Preliminaries

Stopping rule for SMQ.

Even without querying any interval, we know that the minimum value is at most R:=miniN{ri}, the minimum right-endpoint. In order to simplify notation, we incorporate this information using a dummy r.v. X0=[R,R] that is queried at the start of any policy and incurs no cost. We now formally define the condition under which a policy for 𝖲𝖬𝖰 is allowed to stop. We will refer to the partial observations at any point in a policy (i.e., values of r.v.s queried so far) as the state. Consider any state, given by a subset SN of queried r.v.s along with their observations {xi}iS. The minimum observed value is miniSxi and the minimum possible value among the un-queried r.v.s is minjNSj. The stopping criterion is:

miniSximinjNSj+δ. (1)

If this criterion is met then 𝖵𝖠𝖫=miniSxi is guaranteed to satisfy 𝖬𝖨𝖭𝖵𝖠𝖫𝖬𝖨𝖭+δ, where 𝖬𝖨𝖭=minjNXj. Also, argminiSxi is a δ-minimizer. On the other hand, if this criterion is not met then there is no value v that guarantees 𝖬𝖨𝖭v𝖬𝖨𝖭+δ: there is a non-zero probability that the minimum value is minjNSj or miniSxi (and these values are more than δ apart). So,

Proposition 1.1.

A policy for 𝖲𝖬𝖰 can stop if and only if criterion (1) holds.

The stopping rule for 𝖲𝖬𝖰𝖨 is described in §2.2. An 𝖲𝖬𝖰𝖨 policy can stop either due to the 𝖲𝖬𝖰 stopping rule (above) or by inferring an un-queried interval i as a δ-minimizer.

Adaptivity gap.

We show that the adaptivity gap for the 𝖲𝖬𝖰 problem is more than one: so adaptive policies may indeed perform better. This example also builds some intuition for the problem. Consider an instance with three intervals as shown in Figure 2. In particular, X1{0,3,}, X2{1,}, X3{2,} and δ=1. Let Pr(X1=0)=13,Pr(X1=3)=13,Pr(X1=)=13,Pr(X2=1)=ϵ,Pr(X2=)=1ϵ,Pr(X3=2)=1ϵ,Pr(X3=)=ϵ. An adaptive policy is shown in Figure 2, which has cost at most 1+23+ϵ3=5+ϵ3. We present a case analysis in [2] and show that the best non-adaptive cost is min{6ϵ3,5+2ϵ3}. Setting ϵ=13, we obtain an adaptivity gap of 1716. We can also modify this instance slightly to get a worse adaptivity gap of 1211.

Refer to caption
Figure 1: Adaptivity gap instance.
Figure 2: Optimal adaptive policy.

Fixed threshold problem.

In our analysis, we relate 𝖲𝖬𝖰 to the following simpler problem. Given n r.v.s {Xi:iN} with costs as before, a fixed threshold θ and budget k, find a policy having query-cost at most k that maximizes the probability of observing a realization less than θ. A useful property of this fixed threshold problem is that it has adaptivity gap one [2].

Proposition 1.2.

Consider any instance of the fixed threshold problem. Let V and F denote the maximum success probabilities over adaptive and non-adaptive policies respectively. Then, V=F

2 Algorithm for Unit Costs

Before presenting our algorithm, we discuss two simple greedy policies and show why they fail to achieve a good approximation.

  1. 1.

    A natural approach is to select intervals by increasing left-endpoint. Indeed, [21] shows that this algorithm is optimal when δ=0, even in an online setting (with open intervals). Consider the instance with two types of intervals as shown in Figure 3. The r.v.s X1,Xn/2 are identically distributed with Xi=0 w.p. 1n and Xi=n otherwise. The remaining r.v.s Xn/2+1,Xn are identically distributed with Xi=δ2 w.p. 12 and Xi=n otherwise. The greedy policy queries r.v.s in the order 1,2,n, resulting in an expected cost of Ω(n) as it can stop only when it observes a “low” realization for some r.v. However, the policy that probes in the reverse order n,n1,1 has constant expected cost: the policy can stop upon observing any “low” realization (even if a value of δ/2 is observed, it is guaranteed to be within δ of the true minimum). So the approximation ratio of this greedy policy is Ω(n).

    Figure 3: Bad example for greedy by left-endpoint.
  2. 2.

    A different greedy policy (based on the instance in Figure 3) is to always select the interval that maximizes the likelihood of stopping in one step. Now consider another instance with three types of intervals; see Figure 4. The r.v. Xn is always 1.4δ. The r.v. X1 takes value 0 w.p. 12n and has value n otherwise. The remaining r.v.s X2,Xn1 are identically distributed with Xi=δ2 w.p. 1n and Xi=n otherwise. As long as X1 is not queried, the probability of stopping (in one step) is as follows: 12n for X1, 1n for X2,Xn1 and zero for Xn. So this greedy policy will query in the order 2,3,n1,1,n resulting in an Ω(n) expected cost. On the other hand, querying the r.v.s X1 and Xn guarantees that the policy can stop. So the optimal cost is at most 2, implying an Ω(n) approximation ratio.

    Figure 4: Bad example for greedy by stopping probability.

Our approach is to interleave the above two greedy criteria. In particular, each iteration of our algorithm makes two queries: the interval with the smallest left-endpoint and the interval that maximizes the probability of stopping in one step. We will show that this leads to a constant-factor approximation. We first re-number intervals by increasing order of their left-endpoint, i.e., 12n. For each kN, let θk:=k+1+δ. Algorithm 1 describes our algorithm formally.

Algorithm 1 Non-Adaptive Double Greedy.

Equivalently, we can view Algorithm 1 as first computing the permutation π (without querying) and then performing queries in the order given by π until the stopping criterion is met. Note that Algorithm 1 is non-adaptive because it uses observations only to determine when to stop. So, our analysis also upper bounds the adaptivity gap.

We overload notation slightly and use π to also denote the non-adaptive policy given in Algorithm 1. Note that each iteration in this policy involves two queries. We use σ to denote the optimal (adaptive) policy. Let cexp(π) and cexp(σ) denote the expected number of queries in policies π and σ, respectively. The key step in the analysis is to relate the termination probabilities in these two policies, formalized below.

Lemma 2.1.

For any k1, we have

Pr[σ finishes in k queries]Pr[π finishes in 2k iterations].

We will prove this lemma in the next subsection. First, we complete the analysis using this.

Theorem 2.2.

We have cexp(π)4cexp(σ).

Proof.

Let Cσ denote the random variable that captures the number of queries made by the optimal policy σ. Similarly, let Cπ denote the number of queries made by our policy. Using Lemma 2.1 and the fact that policy π makes two queries in each iteration, for any k1 we have

Pr[Cσk]=Pr[σ finishes in k queries]Pr[π finishes in 2k iterations]Pr[Cπ4k] (2)

Hence,

cexp(σ) =0Pr[Cσ>t]𝑑t=0(1Pr[Cσt])𝑑t0(1Pr[Cπ4t])𝑑t
=140(1Pr[Cπy])𝑑y=140Pr[Cπ>y]𝑑y=14cexp(π) (3)

The first equality in (3) is by a change of variables y=4t.

2.1 Proof of Key Lemma

We now prove Lemma 2.1. Fix any k1 and define threshold θ:=θk=k+1+δ.

Let TN denote the optimal solution to the non-adaptive “fixed threshold” problem:

maxTN,|T|kPr[miniTXiθ]. (4)

We then proceed in two steps, as follows.

Pr[σ finishes in k queries]Pr[miniTXiθ]Pr[π finishes in 2k iterations]

The first inequality is shown in Lemma 2.3: this uses the fact that the fixed-threshold problem has adaptivity gap one (Proposition 1.2). The second inequality is shown in Lemma 2.4: this relies on the greedy criteria used in our algorithm.

Lemma 2.3.

Pr[σ finishes in k queries]Pr[miniTXiθ].

Proof.

Let σk denote the optimal policy truncated after k queries: so the cost of σk is always at most k. Let L(σk)=miniNσk{i} denote the smallest un-queried left-endpoint at the end of σk; this is a random value because σk is an adaptive policy. Then,

Pr[σ finishes in k queries] =Pr[miniσkXiL(σk)+δ] (5)
Pr[miniσkXik+1+δ]=Pr[miniσkXiθ] (6)
Pr[miniTXiθ] (7)

Equality (5) is by the stopping criterion for 𝖲𝖬𝖰. The inequality in (6) uses the observation that after any k queries, the smallest un-queried left-endpoint must be at most k+1: so L(σk)k+1 always. The equality in (6) is by definition of the threshold θ. Inequality (7) follows from Proposition 1.2: we view σk is a feasible adaptive policy for the fixed-threshold problem and T is the optimal non-adaptive policy.

Lemma 2.4.

Pr[miniTXiθ]Pr[π finishes in 2k iterations].

Proof.

Recall that each iteration j of Algorithm 1 selects two intervals: j in Step 3 and b(j) in Step 4. Let B={b(1),b(2k)} be the set of intervals chosen by our policy π in Step 4 of the first 2k iterations. We partition B into B={b(1),b(k)} and B′′={b(k+1),b(2k)}. Let d=argmindTBPr(Xd>θk)=argmaxdTBPr(Xdθk).

Pr[miniTXi>θk] =iTPr[Xi>θk]
=iTBPr[Xi>θk]iTBPr[Xi>θk]
iTBPr[Xi>θk](Pr[Xd>θk])|TB| (8)
iTBPr[Xi>θ2k]iB′′TPr[Xi>θ2k] (9)
iBPr[Xi>θ2k]=Pr[miniBXi>θ2k] (10)

(8) follows from the definition of d. (10) just uses that TB and B′′T are disjoint subsets of B. The key step above is (9), which we prove using two cases:

  • Suppose that TB=. Then, using θkθ2k we obtain Pr[Xi>θk]Pr[Xi>θ2k], which proves (9) for this case.

  • Suppose that TB. In this case, d is well-defined. We now claim that:

     For each j=k+1,2k, either b(j)T or Pr[Xb(j)>θ2k]Pr[Xd>θk]. (11)

    Indeed, consider any such j and suppose that b(j)T. As d is a valid choice for b(j), the greedy rule implies:

    Pr[Xd>θj]Pr[Xb(j)>θj].

    Further, using the fact that θkθjθ2k, we get

    Pr[Xd>θk]Pr[Xd>θj]Pr[Xb(j)>θj]Pr[Xb(j)>θ2k],

    which proves (11). Let h denote the number of iterations j{k+1,2k} where b(j)T. Note that h=|B′′||TB′′|=k|TB′′||TB|, where we used |T|=k. Using (11), it follows that Pr[Xi>θ2k]Pr[Xd>θk] for all iB′′T. Hence,

    Pr[Xd>θk]|TB|Pr[Xd>θk]hiB′′TPr[Xi>θ2k],

    Combined with the fact that θkθ2k (as before), we obtain (9).

We are now ready to complete the proof. Using the 𝖲𝖬𝖰 stopping criterion and the fact that π queries all the intervals in B within 2k iterations,

Pr[π finishes in 2k iterations]Pr[miniBXiθ2k]=1Pr[miniBXi>θ2k].

Combined with (10),

Pr[π finishes in 2k iterations]1Pr[miniTXi>θk]=Pr[miniTXiθ],

where we use the definition θ=θk.

2.2 Finding the minimum interval

In this section, we consider the 𝖲𝖬𝖰𝖨 problem, where the goal is to identify an interval that is guaranteed to be a δ-minimizer. Unlike the previous 𝖲𝖬𝖰 setting (where we find a δ-minimum value), for 𝖲𝖬𝖰𝖨 we just want to identify some interval iN such that Xi𝖬𝖨𝖭+δ. Recall that 𝖬𝖨𝖭=miniNXi. It is important to note that the interval i may not have been queried. It is easy to see that any 𝖲𝖬𝖰 policy is also feasible to 𝖲𝖬𝖰𝖨. Indeed, by the stopping rule (1) for 𝖲𝖬𝖰, the δ-minimum value returned is always the minimum value of a queried interval: so we also identify i. However, an 𝖲𝖬𝖰𝖨 policy may return an interval i without querying it. So the optimal value of 𝖲𝖬𝖰𝖨 may be smaller than 𝖲𝖬𝖰.

Remark.

We note that the optimal values of 𝖲𝖬𝖰 and 𝖲𝖬𝖰𝖨 differ by at most the maximum query cost cmax. As noted above, the optimal 𝖲𝖬𝖰𝖨 value is at most that of 𝖲𝖬𝖰. On the other hand, the optimal 𝖲𝖬𝖰 value is at most the optimal 𝖲𝖬𝖰𝖨 value plus the cost to query i. In the unit-cost setting, cmax=1 and any policy has expected cost at least 1: so the optimal values of 𝖲𝖬𝖰 and 𝖲𝖬𝖰𝖨 are within a factor two of each other. This immediately implies that Algorithm 1 is also an 8-approximation for unit-cost 𝖲𝖬𝖰𝖨. In the rest of this subsection, we will prove a stronger result, that Algorithm 1 is a 4-approximation for 𝖲𝖬𝖰𝖨. Apart from the improved constant factor, these ideas will also be helpful for 𝖲𝖬𝖰𝖨 with general costs. We note that under general costs, the optimal 𝖲𝖬𝖰 and 𝖲𝖬𝖰𝖨 values may differ by an arbitrarily large factor because cmax is not a lower bound on the optimal value.

Stopping criteria for SMQI.

Consider any state, given by a subset SN of queried r.v.s along with their observations {xi}iS. There are two conditions under which the 𝖲𝖬𝖰𝖨 policy can stop.

  • The first stopping rule is just the one for 𝖲𝖬𝖰 (1), which corresponds to the situation that interval i is queried. We restate this rule below for easy reference:

    miniSximinjNSj+δ. (12)

    In this case, we return i=argminiSxi. We refer to this as the old stopping rule.

  • The second stopping rule handles the situation where an un-queried interval i is returned. For any iN, define the “almost prefix” set Pi:={jNi:j<riδ}. Note that either Pi or Pii is a prefix of [n]. (As before, we assume that intervals are indexed by increasing order of their left-endpoint, i.e., 12n.) The new rule is:

    iN such that PiS and minjPixjriδ. (13)

    In other words, there is some interval i where (1) all intervals ji with left-endpoint j<riδ have been queried, and (2) the minimum value of these r.v.s is at least riδ. In this case, we return i=i (we may not know a δ-minimum value). We refer to this as the new stopping rule. See Figure 5 for an example.

Proposition 2.5.

A policy for 𝖲𝖬𝖰𝖨 can stop if and only if either criterion (12) or (13) holds.

Figure 5: Illustration of new 𝖲𝖬𝖰𝖨 stopping criterion.

Our algorithm for 𝖲𝖬𝖰𝖨 with unit costs remains the same as for 𝖲𝖬𝖰 (Algorithm 1). The only difference is in the new stopping criterion (described above). Recall that π is the permutation used by our non-adaptive policy. When it is clear from the context, we will also use π to denote our 𝖲𝖬𝖰𝖨 policy that performs queries in the order of π until stopping criteria (12) or (13) applies.

Theorem 2.6.

The non-adaptive policy π is a 4-approximation algorithm for 𝖲𝖬𝖰𝖨.

We now prove this result. Let σ denote an optimal adaptive policy for 𝖲𝖬𝖰𝖨. For any k1, we will show:

Pr[σ finishes in k queries]Pr[π finishes in 2k iterations]. (14)

This would suffice to prove the 4-approximation, exactly as in Theorem 2.2.

In order to prove (14), we fix some k1. As in the previous proof, let θ=θk=k+1+δ and let T be defined as in (4). To reduce notation, define the following events.

𝒜1: our policy π finishes within 2k iterations due to (12).
𝒜2: our policy π finishes within 2k iterations due to (13).
𝒪1: optimal policy σ finishes within k queries due to (12).
𝒪2: optimal policy σ finishes within k queries due to (13).

Handling the old stopping criterion.

Let L denote the smallest un-queried left-endpoint at the end of iteration 2k in π. Note that L is a deterministic value as π is a non-adaptive policy. Moreover, L2k+1 as π would have queried the first 2k r.v.s. Let 𝒢 be the event that Xi>L+δ for all intervals i queried by π in its first 2k iterations. In other words, 𝒢 is precisely the event that stopping criterion (12) does not apply at the end of iteration 2k in π, i.e., 𝒢=¬𝒜1. By Lemma 2.4,

Pr[¬𝒢]=Pr[𝒜1]Pr[miniTXiθ].

Similarly, let 𝒢 be that event that Xi>θ for all intervals i in the first k queries of σ. From the proof of Lemma 2.3, we obtain 𝒪1¬𝒢 and

Pr[¬𝒢]Pr[miniTXiθ].

Combining the above two inequalities, we have

Pr[¬𝒢]Pr[¬𝒢]. (15)

Handling the new stopping criterion.

Let 𝒢A be the event that Xj>L+δ for all r.v.s jN. Similarly, let 𝒢A be the event that Xj>θ for all jN. Clearly,

Pr[𝒜2|𝒢]=Pr[𝒜2|𝒢A]andPr[𝒪2|𝒢]=Pr[𝒪2|𝒢A]. (16)

We will now prove that

Pr[𝒜2|𝒢A]Pr[𝒪2|𝒢A]. (17)

If σ finishes due to (13) in k queries then Pi[k+1]: otherwise |Pi|>k which contradicts with the fact that all r.v.s in Pi must be queried. Let R={iN:Pi[k+1]} be all such intervals. It now follows that the event 𝒪2 (which corresponds to policy σ) is a subset of the event

:=iR(jPi(Xjriδ)). (18)

Note that is independent of the policy: it only depends on the realizations of the r.v.s (and doesn’t depend on whether/not an interval has been queried).

Moreover, our policy π queries all the r.v.s in [2k][k+1] within 2k iterations. So, for all iR, the r.v.s in Pi[k+1] are queried by π in 2k iterations. Hence, event 𝒜2 (which corresponds to policy π) contains event .

Recall that the event 𝒢A (resp. 𝒢A) in policy π (resp. σ) means that every r.v. is more than L+δ (resp. θ). Also, θL+δ, which means

Pr[Xju|Xj>L+δ]Pr[Xju|Xj>θ],u,jN.

In other words, for any jN, if Yj (resp. Zj) is the r.v. Xj conditioned on 𝒢A (resp. 𝒢A) then Yj stochastically dominates Zj.222We say that r.v. Y stochastically dominates Z if Pr[Yu]Pr[Zu] for all u. Note also that the r.v.s Yjs (resp. Zjs) are independent. Using the fact that event corresponds to a monotone function, we obtain:

Lemma 2.7.

Let {Yj:jN} and {Zj:jN} be independent r.v.s such that Yj stochastically dominates Zj for each jN. Then, Pr[(Y1,,Yn)]Pr[(Z1,,Zn)] where event is a function of independent r.v.s as defined in (18).

Proof.

It suffices to prove the following.

Pr[(Y1,,Yk,Zk+1,,Zn)]Pr[(Y1,,Yk1,Zk,,Zn)],k[n].

Note that the r.v.s above only differ at position k. To keep notation simple, for any j[n]k let Xj=Yj if j<k and Xj=Zj if j>k. So, we need to show Pr[(X,Yk)]Pr[(X,Zk)]. We condition on the realizations of the X r.v.s. For each j[n]k let tj denote the realization of the r.v. Xj. Having conditioned on these r.v.s, the only randomness is in Yk and Zk. We will show:

Pr[(X,Yk)|X=t]Pr[(X,Zk)|X=t]. (19)

Using the definition of the event from (18), let R(t)={iR:kPi and tj>riδ for all jPik}. In other words, R(t)R corresponds to those “clauses” in (18) that have not evaluated to true or false based on the realizations {Xj=tj:j[n]k}. If there is some clause in (18) that already evaluates to true (based on t) then holds regardless of Yk or Zk. So, (19) holds in this case (both terms are one). Now, we assume that no clause in (18) already evaluates to true. We can write

{(X,Yk)|X=t}=iR(t)(Ykriδ)={Ykf},

where f=miniR(t)riδ is a deterministic value.333If R(t)= then we set f=. Similarly, we have

{(X,Zk)|X=t}={Zkf}.

Using the fact that Yk (resp. Zk) is independent of X and that Yk stochastically dominates Zk,

Pr[(X,Yk)|X=t]=Pr[Ykf]Pr[Zkf]=Pr[(X,Zk)|X=t].

This completes the proof of (19). De-conditioning the X r.v.s, we obtain Pr[(X,Yk)]Pr[(X,Zk)] as desired.

Using Lemma 2.7, we obtain Pr[|𝒢A]Pr[|𝒢A], which proves (17). Combined with (16),

Pr[𝒜2|𝒢]Pr[𝒪2|𝒢]. (20)

Wrapping up.

We have

Pr[𝒜1𝒜2] =Pr[𝒜1]+Pr[𝒜2¬𝒜1]=Pr[¬𝒢]+Pr[𝒜2𝒢]
=Pr[¬𝒢]+Pr[𝒜2|𝒢]Pr[𝒢]=1(1Pr[𝒜2|𝒢])Pr[𝒢]
1(1Pr[𝒪2|𝒢])Pr[𝒢] by (15) and (20)
=Pr[¬𝒢]+Pr[𝒪2𝒢]
Pr[𝒪1]+Pr[𝒪2¬𝒪1] using 𝒪1¬𝒢
=Pr[𝒪1𝒪2].

This completes the proof of (14) and the theorem.

3 Algorithm for General Costs

We now consider the 𝖲𝖬𝖰 problem with non-uniform query costs. The high-level idea is similar to the unit-cost case: interleaving the two greedy criteria of smallest left-endpoint and highest probability of stopping. However, we need to incorporate the costs carefully. To this end, we use an iterative algorithm that in every iteration g, makes a batch of queries having total cost about 2g. (In order to optimize the approximation ratio, we use a generic base y for the exponential costs.)

We extend the algorithm and analysis in this section to get a 7.47 approximation for the 𝖲𝖬𝖰𝖨 with non-uniform costs in [2].

For any subset SN, let c(S):=jScj denote the cost of querying all intervals in S. Again, we renumber intervals so that 12n.

Definition 3.1.

For any g0, let Tg be the maximal prefix of intervals having cost at most yg.

Algorithm 2 Double Greedy for General Cost.

The complete algorithm is given in Algorithm 2. The optimization problem (KP) solved in Step 5 is a variant of the classic knapsack problem: in Theorem 3.2 we provide a (1,1+ϵ) bicriteria approximation algorithm for (KP) for any constant ϵ>0. In particular, this ensures that c(Ug)yg(1+ϵ) and

Pr[minjUgXj>θg]pg.

Note that the left-hand-side above equals jUgPr[Xj>θg] as all r.v.s are independent.

Theorem 3.2.

Given discrete random variables {Xi}i=1n with costs {ci}i=1n, budget d and threshold θ, there is an nO(1/ϵ) time algorithm that finds TN such that Pr[minjTXj>θ]p and c(T)(1+ϵ)d, for any ϵ>0. Here,

p=minTN{Pr[minjTXj>θ]:c(T)d}.

The proof of Theorem 3.2 is presented in [2].

Furthermore, just like Algorithm 1, we can view Algorithm 2 as first computing the permutation π (without querying) and then performing queries in that order until the stopping criterion. So, our algorithm is a non-adaptive policy and our analysis also upper-bounds the adaptivity gap.

3.1 Analysis

We use σ to denote the optimal (adaptive) policy and π to denote our non-adaptive policy.

Definition 3.3.

For any g0, let

og:=Pr[σ does not finish by cost yg].

Similarly, for our policy we define

vg:=Pr[π does not finish by iteration g].

We also define σg to be the optimal policy truncated at cost yg, i.e., the total cost of queried intervals is always at most yg. Similarly, we define πg to be our policy truncated at the end of iteration g.

The key part of the analysis lies in relating the non-stopping probabilities og and ag in the optimal and algorithmic policies: see Lemma 3.5. Our first lemma bounds the (worst-case) cost incurred in g iterations of our policy.

Lemma 3.4.

The cost of our policy until the end of iteration g is

c(πg)(1+ϵ)(1+yy1)yg.

Proof.

We handle separately the costs of intervals queried in Steps 3 and 6. The total cost incurred in Step 3 of the first g iterations is c(Tg)yg: this uses k=0gTk=Tg because Tg are prefixes. The total cost due to Step 6 can be bounded using a geometric series:

k=0gc(Uk)(1+ϵ)k=0gyk=(1+ϵ)yg+11y1.

The inequality above is by the cost guarantee for (KP). The lemma now follows.

Lemma 3.5.

For all g0, we have agog.

Proof.

Recall that σg denotes the optimal policy truncated at cost yg. We let L(σg)=minjNσg{j} be the smallest un-queried left-endpoint: this is a random value as σg is adaptive. In the algorithm, consider iteration g and let L(Tg)=minjNTg{j}; note that the threshold θgL(Tg)+δ in Step 4. Let π=πg1Tg denote the list after Step 3 in iteration g. Note that the optimization in (KP) of iteration g is over TNπ, which yields Ug. Also, πg=πUg.

og =Pr[OPT does not finish within cost yg]
=Pr[minjσgXj>L(σg)+δ]Pr[minjσgXj>L(Tg)+δ] (21)
Pr[minjσgXj>θg]=1Pr[minjσgXjθg] (22)
1maxTN,c(T)ygPr[minjTXjθg]=minTN,c(T)ygPr[minjTXj>θg] (23)
=minTN,c(T)ygjTPr[Xj>θg]jπPr[Xj>θg]minTNπ,c(T)ygjTPr[Xj>θg] (24)
=jπPr[Xj>θg]pg=Pr[minjπXj>θg]pg (25)
Pr[minjπXj>θg]Pr[minjUgXj>θg]=Pr[minjπgXj>θg]vg (26)

The equality in (21) is given by the definition of L(σg) and the stopping rule. The inequality in (21) uses the fact that L(σg)L(Tg) always, which in turn is because σg has cost at most yg and Tg is the maximal prefix within this cost. The inequality in (22) uses θgL(Tg)+δ. The inequality in (23) is by Proposition 1.2: we view σg as a feasible adaptive policy for the fixed-threshold problem with threshold θg and budget yg. The equality in (24) follows from independence of the random variables. The first equality in (25) uses the definition of pg from (KP) and independence. The first inequality in (26) uses the choice of Ug and Theorem 3.2. The equality in (26) is by πg=πUg. To see the last inequality in (26), note that if minjπi{Xj}θg then π finishes by iteration g.

In Lemma 3.6 we lower bound the expected cost of the optimal policy. Let cexp(π) and cexp(σ) denote the expected cost of our greedy policy and the optimal policy, respectively.

Lemma 3.6.

For any base y1, we have g0ygogyy1cexp(σ)1y1.

Proof.

Let Z denote the random variable that represents the cost of the optimal policy σ: so cexp(σ)=𝔼[Z]. Let 𝟏(Z>yg) be the indicator variable for when Z>yg; so 𝔼[I(Z>yg)]=og. We now show that:

g0yg𝟏(Z>yg) yy1Z1y1 (27)

To see this, suppose that yk<Zyk+1 for some integer k0. Then the left-hand-side of (27) equals

g=0kyg=yk+11y1Zyy11y1,

which proves (27). Taking the expectation of (27) proves the lemma.

Theorem 3.7.

There is a (3+22+ϵ)-approximation for the 𝖲𝖬𝖰 problem with general costs.

Proof.

By Lemma 3.4, we have cexp(π)(1+ϵ)(1+yy1)g1yg(vg1vg). Now,

g1yg(vg1vg) =v0+(y1)g0ygvg1+(y1)g0ygog (28)
1+(y1)g0ygog1+ycexp(σ)1=ycexp(σ) (29)

The inequality in (28) is by Lemma 3.4 and v0=1. The first inequality in (29) uses y1 and the second inequality is by Lemma 3.6.

Hence, we obtain cexp(π)(1+ϵ)y(1+yy1)cexp(σ). Now, optimizing for y, we obtain the stated approximation ratio.

References

  • [1] Marek Adamczyk, Maxim Sviridenko, and Justin Ward. Submodular stochastic probing on matroids. Math. Oper. Res., 41(3):1022–1038, 2016. doi:10.1287/MOOR.2015.0766.
  • [2] Hessa Al-Thani and Viswanath Nagarajan. Identifying approximate minimizers under stochastic uncertainty, 2025. arXiv:2504.17019.
  • [3] Arash Asadpour and Hamid Nazerzadeh. Maximizing stochastic monotone submodular functions. Manag. Sci., 62(8):2374–2391, 2016. doi:10.1287/MNSC.2015.2254.
  • [4] Evripidis Bampis, Christoph Dürr, Thomas Erlebach, Murilo Santos de Lima, Nicole Megow, and Jens Schlöter. Orienting (hyper)graphs under explorable stochastic uncertainty. In 29th Annual European Symposium on Algorithms (ESA), volume 204 of LIPIcs, pages 10:1–10:18, 2021. doi:10.4230/LIPICS.ESA.2021.10.
  • [5] N. Bansal, A. Gupta, J. Li, J. Mestre, V. Nagarajan, and A. Rudra. When LP is the cure for your matching woes: Improved bounds for stochastic matchings. Algorithmica, 63(4):733–762, 2012. doi:10.1007/S00453-011-9511-8.
  • [6] Steven Chaplick, Magnús M. Halldórsson, Murilo S. de Lima, and Tigran Tonoyan. Query minimization under stochastic uncertainty. Theoretical Computer Science, 895:75–95, 2021. doi:10.1016/J.TCS.2021.09.032.
  • [7] B. C. Dean, M. X. Goemans, and J. 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.
  • [8] Thomas Erlebach, Michael Hoffmann, and Frank Kammer. Query-competitive algorithms for cheapest set problems under uncertainty. Theoretical Computer Science, 613:51–64, 2016. doi:10.1016/J.TCS.2015.11.025.
  • [9] Thomas Erlebach, Michael Hoffmann, Danny Krizanc, Matús Mihal’Ák, and Rajeev Raman. Computing minimum spanning trees with uncertainty. In STACS, pages 277–288, 2008.
  • [10] Tomás Feder, Rajeev Motwani, Rina Panigrahy, Chris Olston, and Jennifer Widom. Computing the median with uncertainty. In Proceedings of the thirty-second annual ACM symposium on Theory of computing, pages 602–607, 2000. doi:10.1145/335305.335386.
  • [11] Hao Fu, Jian Li, and Pan Xu. A PTAS for a class of stochastic dynamic programs. In 45th International Colloquium on Automata, Languages, and Programming (ICALP), volume 107 of LIPIcs, pages 56:1–56:14, 2018. doi:10.4230/LIPICS.ICALP.2018.56.
  • [12] Dimitrios Gkenosis, Nathaniel Grammel, Lisa Hellerstein, and Devorah Kletenik. The Stochastic Score Classification Problem. In 26th Annual European Symposium on Algorithms (ESA), pages 36:1–36:14, 2018. doi:10.4230/LIPICS.ESA.2018.36.
  • [13] Ashish Goel, Sudipto Guha, and Kamesh Munagala. How to probe for an extreme value. ACM Transactions on Algorithms (TALG), 7(1):1–20, 2010. doi:10.1145/1868237.1868250.
  • [14] Sudipto Guha and Kamesh Munagala. Approximation algorithms for budgeted learning problems. In 39th Annual ACM Symposium on Theory of Computing (STOC), pages 104–113. ACM, 2007. doi:10.1145/1250790.1250807.
  • [15] Anupam Gupta, Ravishankar Krishnaswamy, Viswanath Nagarajan, and R. Ravi. Running errands in time: Approximation algorithms for stochastic orienteering. Math. Oper. Res., 40(1):56–79, 2015. doi:10.1287/MOOR.2014.0656.
  • [16] Anupam Gupta, Viswanath Nagarajan, and Sahil Singla. Adaptivity gaps for stochastic probing: Submodular and XOS functions. In Twenty-Eighth Annual ACM-SIAM Symposium on Discrete Algorithms (SODA), pages 1688–1702. SIAM, 2017. doi:10.1137/1.9781611974782.111.
  • [17] Lisa Hellerstein, Devorah Kletenik, and Srinivasan Parthasarathy. A tight bound for stochastic submodular cover. J. Artif. Intell. Res., 71:347–370, 2021. doi:10.1613/JAIR.1.12368.
  • [18] Lisa Hellerstein, Naifeng Liu, and Kevin Schewior. Quickly determining who won an election. In 15th Innovations in Theoretical Computer Science Conference (ITCS), LIPIcs, pages 61:1–61:14, 2024. doi:10.4230/LIPICS.ITCS.2024.61.
  • [19] Sungjin Im, Viswanath Nagarajan, and Ruben van der Zwaan. Minimum latency submodular cover. ACM Trans. Algorithms, 13(1):13:1–13:28, 2016. doi:10.1145/2987751.
  • [20] Haotian Jiang, Jian Li, Daogao Liu, and Sahil Singla. Algorithms and adaptivity gaps for stochastic k-tsp. In 11th Innovations in Theoretical Computer Science Conference (ITCS), volume 151 of LIPIcs, pages 45:1–45:25, 2020. doi:10.4230/LIPICS.ITCS.2020.45.
  • [21] Simon Kahan. A model for data in motion. In Proceedings of the Twenty-third Annual ACM Symposium on Theory of computing, pages 265–277, 1991.
  • [22] Nicole Megow, Julie Meißner, and Martin Skutella. Randomization helps computing a minimum spanning tree under uncertainty. SIAM Journal on Computing, 46(4):1217–1240, 2017. doi:10.1137/16M1088375.
  • [23] Nicole Megow and Jens Schlöter. Set selection under explorable stochastic uncertainty via covering techniques. In International Conference on Integer Programming and Combinatorial Optimization, pages 319–333. Springer, 2023. doi:10.1007/978-3-031-32726-1_23.
  • [24] Danny Segev and Sahil Singla. Efficient approximation schemes for stochastic probing and prophet problems. In 22nd ACM Conference on Economics and Computation (EC), pages 793–794. ACM, 2021. doi:10.1145/3465456.3467614.
  • [25] Sahil Singla. The price of information in combinatorial optimization. In Proceedings of the Twenty-Ninth Annual ACM-SIAM Symposium on Discrete Algorithms (SODA), pages 2523–2532. SIAM, 2018. doi:10.1137/1.9781611975031.161.
  • [26] Weina Wang, Anupam Gupta, and Jalani K Williams. Probing to minimize. In 13th Innovations in Theoretical Computer Science Conference (ITCS 2022), volume 215, page 120, 2022.

Appendix A Multiplicative Precision

Given an instance with non-negative r.v.s {Xi}i=1n and multiplicative precision α1, consider a new instance of 𝖲𝖬𝖰 with r.v.s {Xi:=ln(Xi)}i=1n and additive precision δ:=lnα. Note that

𝖬𝖨𝖭=mini=1nXi=mini=1nln(Xi)=ln(mini=1nXi)=ln(𝖬𝖨𝖭).

An α-approximately minimum value W for the original instance satisfies 𝖬𝖨𝖭Wα𝖬𝖨𝖭, where 𝖬𝖨𝖭=mini=1nXi. Then, 𝖵𝖠𝖫=ln(W) satisfies 𝖬𝖨𝖭=ln(𝖬𝖨𝖭)𝖵𝖠𝖫ln(𝖬𝖨𝖭)+lnα=𝖬𝖨𝖭+δ, i.e., 𝖵𝖠𝖫 is a δ-minimum value for the new instance. Similarly, if 𝖵𝖠𝖫 is a δ-minimum value for the new instance then W:=e𝖵𝖠𝖫 is an α-approximately minimum value for the original instance.

Appendix B Bad Example for Competitive Ratio

We provide an example that rules out any reasonable competitive ratio bound for 𝖲𝖬𝖰 and 𝖲𝖬𝖰𝖨 with precision δ>0. This is in sharp contrast to the corresponding problem with exact precision (δ=0) for which a constant competitive ratio is known [21]. We note that results in the online setting assume open intervals, which in our setting (with discrete r.v.s) corresponds to all left-endpoints being distinct.444Alternatively, our example can be modified into one with open intervals where the competivity ratio is still Ω~(n). The benchmark in the online setting is the hindsight optimum, which is the minimum number (or cost) of queries that are needed to verify a δ-minimum value conditioned on the realizations {xi}i=1n of the r.v.s.

Consider an instance with n r.v.s with Pr[Xi=i]=lnnn and Pr[Xi=n2]=1lnnn for all i[n]. All costs are unit and the precision δ=n. We refer to the values {1,2,n} as low values: note that any low value is a δ-minimum value for this instance.

We first consider the hindsight optimum. If any of the n r.v.s (say k) realizes to a low value then verifying the δ-minimum value just requires querying k, which has cost 1. On the other hand, the probability that none of the n r.v.s realizes to a low value is (1lnnn)n1n: in this case the optimal verification cost is n (querying all r.v.s). So the expected optimal cost is at most 2.

Now, consider an 𝖲𝖬𝖰 policy: this does not know the realizations. It is easy to see that the only way to stop querying is when some low value is observed (or all n r.v.s are queried). So, the expected cost of any policy is at least nlnn. Hence the competitive ratio for 𝖲𝖬𝖰 is Ω(nlnn).