Learning Unanimously Acceptable Lotteries via Queries

Abstract: Many high-stakes AI deployments proceed only if every stakeholder deems the system acceptable relative to their own minimum standard. With randomization over a finite menu of options, this becomes a feasibility question: does there exist a lottery over options that clears all stakeholders' acceptability bars? We study a query model where the algorithm proposes lotteries and receives only binary accept/reject feedback. We give deterministic and randomized algorithms that either find a unanimously acceptable lottery or certify infeasibility; adaptivity can avoid eliciting many stakeholders' constraints, and randomization further reduces the expected elicitation cost relative to full elicitation. We complement these upper bounds with worst-case lower bounds (in particular, linear dependence on the number of stakeholders and logarithmic dependence on precision are unavoidable). Finally, we develop learning-augmented algorithms that exploit natural forms of advice (e.g., likely binding stakeholders or a promising lottery), improving query complexity when predictions are accurate while preserving worst-case guarantees.

• The paper introduces efficient query algorithms, such as LearnHyperplane, to reconstruct agent acceptability thresholds using binary feedback.
• It presents deterministic and randomized adaptive approaches that yield optimal query complexities by leveraging the geometry of the simplex and predictive advice.
• The study establishes tight lower bounds and integrates learning-augmented mechanisms, ensuring robust and practical AI governance in high-stakes settings.

Learning Unanimously Acceptable Lotteries via Binary Query Elicitation

Problem Formulation and Motivation

The paper "Learning Unanimously Acceptable Lotteries via Queries" (2604.17505) analyzes the information-theoretic and computational complexity of finding a randomized deployment (a lottery over a finite set of alternatives) that is acceptable to all stakeholders, given only access to coarse, binary (accept/reject) feedback regarding candidate lotteries. Each stakeholder (agent) possesses an unknown utility vector and a personal acceptability threshold, with acceptability defined as expected utility exceeding this threshold. The setting targets high-stakes, governance-oriented AI deployment scenarios, such as model releases, where all stakeholders' minimal standards must be met (conservative gatekeeping).

Randomization (lottery selection) is explicitly allowed: no deterministic alternative may clear all bars, but mixing over alternatives typically convexifies the feasible region and makes simultaneous satisfaction possible. Crucially, the elicitation channel is restricted: stakeholders do not report full utilities, but only whether a proposed lottery is acceptable.

Formally, with $n$ agents and $m$ alternatives, each agent $i$ has an unknown utility vector $\mathbf{u}_i\in[0,1]^m$ and unknown threshold $\tau_i\in(0,1]$. The algorithm can query acceptability of $x\in\Delta(S)$ (the simplex) for agent $i$, receiving a binary signal ($\langle\mathbf{u}_i,x\rangle \ge \tau_i$). The objective is to find $x$ that all agents accept, or prove infeasibility, with as few queries as possible. The analysis is under $\varepsilon$-granularity, i.e., utilities and thresholds are multiples of $m$0.

Algorithmic Results

Single-Agent Elicitation

The core technical advance is a membership-query procedure, LearnHyperplane, for reconstructing an agent's acceptability halfspace using only binary feedback, without full utility recovery. This procedure exploits the simplex geometry: by querying pure lotteries, it partitions coordinates into universally accepted/rejected, and reconstructs the acceptability boundary by finding "turning points" (threshold-crossing locations) on $m$1 edges of the simplex, using bisection. The total query complexity is $m$2 per agent.

Multi-Agent Unanimity Search

Two principal algorithmic strategies are proposed for the multi-agent problem:

• Deterministic Adaptive Algorithm: Constraints are elicited lazily—an agent's acceptability boundary is only learned if the current candidate lottery violates that agent. This algorithm outputs a unanimously acceptable lottery if one exists, or returns Null with an infeasibility certificate. Its query complexity is $m$3, where the $m$4 arises from worst-case verification queries across agents.
• Randomized Clarkson-Style Algorithm: By random sampling and multiplicative reweighting, inspired by Clarkson’s low-dimensional LP techniques, the expected number of full agent elicitation steps (calls to LearnHyperplane) is dramatically reduced: only $m$5 agent's constraints are learned in expectation, plus $m$6 total queries. When $m$7, the algorithm learns a vanishing fraction of agents' constraints, while guaranteeing correctness. The algorithm matches the geometric witness set complexity of the simplex (Helly number for intersection of halfspaces).

Both algorithms return explicit infeasibility witnesses at no additional oracle cost.

Lower Bounds and Query Complexity Barriers

The authors establish tight lower bounds, showing that for any (randomized or deterministic) correct algorithm, the number of queries required is at least $m$8 in the worst case, even when all utilities are binary. For $m$9 agent, a lower bound of $i$0 queries is proved. Thus, the linear dependence on $i$1, the dependence on the geometry of the simplex, and the logarithmic dependence on required precision are unavoidable.

Learning-Augmented Algorithms

A major contribution is the formal integration of learning-augmented (predictive/advice-driven) mechanisms in the elicitation process, achieving query savings when predictions are accurate while retaining worst-case robust guarantees. Two advice types are considered:

• Permutation (Agent Order) Advice: The algorithm is given a permutation $i$2 predicting the order in which constraints are likely to be active (i.e., ranking most constraining agents first). If the advice is accurate, fewer agent constraints are elicited ($i$3 record agents sufficing), leading to query complexity $i$4. For the randomized algorithm, sampling can be biased toward early agents, reducing expected rounds to $i$5, where $i$6 is a prefix-witness parameter.
• Lottery Advice: The algorithm may also be given a predicted lottery $i$7 believed to be near the feasible region. This serves as a warm start for all binary searches in LearnHyperplane, reducing elicitation cost for an agent $i$8 to $i$9, with $\mathbf{u}_i\in[0,1]^m$0 the maximal projection error on relevant edges. If the advice is exact, only $\mathbf{u}_i\in[0,1]^m$1 queries suffices; otherwise performance degrades smoothly.

All learning-augmented algorithms maintain robustness: with poor predictions, query complexity falls back to non-predictive worst-case bounds.

Comparison to Prior Work

The query model is closely connected to classical membership query learning of halfspaces, multi-agent preference elicitation, and property testing. However, the objective here is not full utility recovery but existential feasibility: finding a point in the intersection of a family of halfspaces (or certifying emptiness), with oracle access strictly limited to accept/reject queries and no explicit reward/utility gradients. Lower bounds leverage convex geometry (Helly-type combinatorics), while upper bounds match the best possible dependence on problem parameters.

The analysis also connects to constrained MDPs, combinatorial mechanism design, and robust ML governance, but focuses specifically on the elicitation cost rather than policy optimization.

Implications and Future Directions

This work provides a rigorous characterization, both upper and lower bounds, for the query complexity of conservative AI deployment when only binary accept/reject feedback is available. The introduction of learning-augmented mechanisms aligns well with realistic ML governance, where historical data or offline evaluation can inform agent orderings or suggest candidate solutions. The practical implication is that query-efficient multi-agent deployment is possible, but feedback granularity and the number of diverse stakeholders impose fundamental informational constraints.

For future directions, two main axes are suggested:

• Noisy/Probabilistic Oracles: Extending the theory to deal with stochastic, inconsistent, or mistake-prone accept/reject signals, typical in human evaluation.
• Beyond Unanimity: Studying other collective decision objectives (e.g., maximizing the number or weight of satisfied agents) is shown to be computationally intractable (NP-hard) even with full elicitation, justifying the focus on the unanimity baseline.

More broadly, the geometric, query-based framework can inform the design of robust, auditable deployment pipelines for high-stakes AI, balancing governance constraints with practical information costs.

Conclusion

The paper rigorously establishes the query complexity of learning a unanimously acceptable randomized deployment via accept/reject queries, contributing adaptive, randomized, and learning-augmented algorithms matching worst-case optimality. Lower bounds firmly delimit what can be achieved information-theoretically in terms of $\mathbf{u}_i\in[0,1]^m$2 (number of agents), $\mathbf{u}_i\in[0,1]^m$3 (number of alternatives), and $\mathbf{u}_i\in[0,1]^m$4 (precision). The work opens technical pathways for further integration of predictive advice and for robustly managing elicitation when direct stakeholder input is costly, minimal, or noisy.