Abstract 1 Introduction 2 Notations and Preliminaries 3 𝓞~(𝑻𝟐/𝟑) Partial-Feedback Upper Bound for Independent Values 4 𝛀(𝑻𝟑/𝟒) Partial-Feedback Lower Bound for Correlated Values References Appendix A Additional Lower Bounds

Tight Regret Bounds for Fixed-Price Bilateral Trade

Houshuang Chen ORCID Shanghai Jiao Tong University, China    Yaonan Jin ORCID Huawei’s Taylor Lab, Beijing, China    Pinyan Lu ORCID Laboratory of Interdisciplinary Research of Computation and Economics (SUFE), Shanghai University of Finance and Economics, China
Huawei’s Taylor Lab, Beijing, China
   Chihao Zhang ORCID Shanghai Jiao Tong University, China
Abstract

We examine fixed-price mechanisms in bilateral trade through the lens of regret minimization. Our main results are twofold. (i) For independent values, a near-optimal Θ~(T2/3) tight bound for Global Budget Balance fixed-price mechanisms with two-bit/one-bit feedback. (ii) For correlated/adversarial values, a near-optimal Ω(T3/4) lower bound for Global Budget Balance fixed-price mechanisms with two-bit/one-bit feedback, which improves the best known Ω(T5/7) lower bound obtained in the work [3] and, up to polylogarithmic factors, matches the 𝒪~(T3/4) upper bound obtained in the same work. Our work in combination with the previous works [5, 6, 2, 3] (essentially) gives a thorough understanding of regret minimization for fixed-price bilateral trade.

En route, we have developed two technical ingredients that might be of independent interest: (i) A novel algorithmic paradigm, called fractal elimination, to address one-bit feedback and independent values. (ii) A new lower-bound construction with novel proof techniques, to address the Global Budget Balance constraint and correlated values.

Keywords and phrases:
bilateral trade, online learning, regret minimization, budget balance
Category:
Track A: Algorithms, Complexity and Games
Funding:
Chihao Zhang: Huawei TC20240329014.
Copyright and License:
[Uncaptioned image] © Houshuang Chen, Yaonan Jin, Pinyan Lu, and Chihao Zhang; licensed under Creative Commons License CC-BY 4.0
2012 ACM Subject Classification:
Theory of computation Algorithmic mechanism design
; Theory of computation Computational pricing and auctions ; Theory of computation Query learning ; Theory of computation Regret bounds
Related Version:
Full Version: https://arxiv.org/abs/2504.04349 [7]
Editors:
Sayan Bhattacharya, Danupon Nanongkai, Michael Benedikt, and Gabriele Puppis

1 Introduction

We address a classic problem in Mechanism Design, maximizing economic efficiency in repeated bilateral trade: In each round t[T], a (new) seller and a (new) buyer seek to trade an indivisible item, which has value St to the seller and value Bt to the buyer. There are two standard metrics of economic efficiency:
1. Gains from Trade, defined as GFT=t[T]GFTt=t[T](BtSt)Zt.
2. Social Welfare, defined as SW=t[T]SWt=t[T](BtZt+St(1Zt)).
Here, Zt=Zt(St,Bt){0,1} denotes the trade outcome – either a success or a failure.

As is standard in Mechanism Design, there are three models for generating values (St,Bt)t[T], listed below from most to least general.

  • Adversarial Values: An (oblivious) adversary determines an (arbitrary) 2T-dimensional [0,1]2T- supported joint distribution 𝒟; then, the values (St,Bt)t[T] across all rounds are drawn from it.

  • Correlated Values: An adversary determines an (arbitrary) two-dimensional [0,1]2-supported joint distribution 𝒟; then, the values (St,Bt) in each round t[T] are drawn i.i.d. from it.

  • Independent Values: This is identical to “correlated values”, except that 𝒟 is further required to be a product distribution 𝒟S𝒟B, making all the 2T values (St,Bt)t[T] mutually independent.

For reference, the “independent values” model is arguably the most canonical model, dating back to seminal works [13, 12], while the other two models are more general and have also received growing attention recently [4, 5, 6, 2, 3, 8].

In this work, we focus on fixed-price mechanisms from the perspective of (additive) regret minimization, by which Social Welfare and Gains from Trade are interchangeable since their gap SWGFT=t[T]St is mechanism-independent. Without loss of generality, we adopt Gains from Trade for our presentation. Such a mechanism posts two possibly randomized prices (Pt,Qt) in each round t[T], one for the seller Pt and one for the buyer Qt. A trade occurs if both agents accept their respective prices: Zt=𝟙[StPtQtBt]{0,1}. This yields the Gains from Trade GFTt=(BtSt)Zt and the profit Profitt=(QtPt)Zt. Throughout this work, we use the term mechanisms to refer to fixed-price mechanisms when no ambiguity arises.

Moreover, economic viability requires the Budget Balance (BB) constraint, which prevents the mechanism from subsidizing the agents. Regarding the BB constraint, prior works have examined two notions, a stricter Local Budget Balance (LBB) constraint [12] and a looser Global Budget Balance (GBB) constraint [3].

  • Local Budget Balance: This can be further differentiated into a stricter Strong Budget Balance (SBB) constraint and a looser Weak Budget Balance (WBB) constraint.

    • Strong Budget Balance: Profitt=0 (or essentially Pt=Qt), t[T].

    • Weak Budget Balance: Profitt0 (or essentially PtQt), t[T].

  • Global Budget Balance: t[T]Profitt0 ex-post.
    This requires nonnegative total profit t[T]Profitt0, almost surely.

As is usual in Online Optimization, the design and analysis of a mechanism depend on the underlying feedback model – the trade information revealed at the end of each round t[T]. Prior works [5, 6, 2, 3] have studied two feedback models, the more informative full feedback and the less informative partial feedback.

  • Full Feedback: This reveals both agents’ values (St,Bt)[0,1]2.

  • Partial Feedback: This can be further differentiated into the more informative two-bit feedback (i.e., both agents’ intentions to trade) and the less informative one-bit feedback (i.e., the trade’s success/failure outcome).

    • Two-Bit Feedback: (Xt,Yt)=(𝟙[StPt],𝟙[QtBt]){0,1}2.

    • One-Bit Feedback: Zt=𝟙[StPtQtBt]XtYt{0,1}.

For full feedback, the picture is essentially complete. Prior work [5, 3] shows Θ~(T1/2) regret for independent/correlated values, and GBB mechanisms also achieve Θ~(T1/2) regret in the adversarial setting, whereas LBB mechanisms suffer linear regret [5, 2]. We therefore focus on partial feedback, where the main gaps remain. Since previous work [5, 2] has shown that linear regret is inevitable under the LBB constraint, we concentrate on the following three settings: GBB partial-feedback mechanisms for independent/correlated/adversarial values.

Together with prior work, our results complete the regret-minimization picture for fixed-price bilateral trade up to polylogarithmic factors. Table 1 summarizes our main results. We also introduce two technical ingredients – fractal elimination and a new GBB lower-bound construction – which may be useful in related online mechanism-design problems.

Table 1: Regret bounds of GBB partial-feedback fixed-price mechanisms, up to polylogarithmic factors.
Global Budget Balance
Previous Lower/Upper Bounds Current Tight Bounds
Independent [T1/2,T3/4] [Thm 12] [3] T2/3 [Thms 11 & 1]
Correlated [T5/7,T3/4] [3] T3/4 [Thm 6] [3]
Adversarial

1.1 Technical Overview

To achieve the results presented in Table 1, we have developed several technical ingredients that may be of independent interest. We highlight the two most important contributions:

  • Ingredient 1: A novel algorithmic paradigm called fractal elimination for devising one-bit-feedback mechanisms for “independent values”. It is inspired by the recursive structure of fractals; see the full version for the geometric intuition behind the name.

  • Ingredient 2: A new lower-bound construction for “correlated values”.

For readability, we omit many minor technical details.

Ingredient 1: Fractal Elimination for One-Bit Feedback and Independent Values

We begin by explaining why one-bit feedback greatly complicates the design of low-regret mechanisms for “independent values (S,B)𝒟S𝒟B”. The algorithmic framework proposed in [3] allows us to first accumulate sufficient profit and then discretize the action space near the diagonal. For an action (p,q)[0,1]2 with pq, we can express the expected Gains from Trade as follows [5, Lemma 1]:

GFT(p,q)=0p𝒟S(x)dx(1𝒟B(q))+𝒟S(p)q1(1𝒟B(y))dy+[minor terms].

Here we abuse notation: 𝒟S(p):=S𝒟S[Sp] and 𝒟B(q):=1B𝒟B[Bq]=B𝒟B[B<q] denote the corresponding cumulative distribution functions (CDF’s).

To adapt a classic Multi-Armed Bandit (MAB) algorithm into a low-regret mechanism, we require “good enough” estimates of the GFT(p,q) values. The query complexity for this task depends critically on the available feedback.

  • Two-Bit Feedback (Xt,Yt): As observed in [5], with access to the seller’s intention to trade Xt, only 𝒪~(ε2) queries/rounds are needed to estimate the integral 0p𝒟S(x)dx within error ε>0, pointwise over the entire interval p[0,1]; similarly for q1(1𝒟B(y))dy. Thus, estimating GFT(p,q) reduces to estimating 𝒟S(p) and 1𝒟B(q). Crucially, the two bits Xt and Yt themselves serve as unbiased estimators for these quantities.

    Feeding Xt and Yt into a standard MAB algorithm directly yields an 𝒪(T2/3) regret GBB mechanism (building on the two-phase meta-mechanism framework from [3, Section 3]).

  • One-Bit Feedback Zt: In contrast, with access only to the trade outcome Zt, we lose the tailored unbiased estimators for 𝒟S(p), 1𝒟B(q) etc., which constitutes our main technical challenge. Prior work [5, Algorithm 4] demonstrated how to construct unbiased estimators of GFT(p,q) from the less informative Zt queries. They showed that 𝒪~(ε2) queries still suffice for ε-approximations. Although their estimators are optimal in query complexity, the resulting 𝒪~(T3/4) regret mechanism is suboptimal in regret, because their estimators inherently incur constant regret per query/round, rather than diminishing regret.

This leads to the core challenge for designing a low-regret GBB one-bit-feedback mechanism:

How can we regret-optimally estimate the GFT(p,q) values?

Our main contribution is an elimination-based multi-stage algorithm, FractalElimination, that addresses this challenge and yields an 𝒪~(T2/3) regret mechanism. The key idea is that when estimating 𝒟S(p), we decompose it into a product of ratios and estimate these ratios recursively. Although the initial actions incur constant regret, they converge exponentially fast to the diagonal {(p,q)| 0p=q1} as the recursion depth increases (i.e., as the algorithm proceeds stage by stage), resulting in diminishing regret. Overall, the total regret is at most 𝒪~(T2/3).

Elimination Algorithms for the Standard MAB Problem.

For readability, it is helpful to review the standard MAB problem and the elimination algorithms: there are K arms whose (independent) random rewards follow the Bernoulli distributions 𝙱𝚎𝚛𝚗(ρi) with mean rewards ρi[0,1], i[K].

An elimination algorithm operates in L+1=log(1ε)+1 stages, for some parameter ε=ε(T,K)>0 to be determined. In stage [0:L], we pull each arm 2/ε times; by standard concentration inequalities, with high probability we can identify and eliminate those Ω(ε/2)-suboptimal mean rewards. After all stages, the rest of the entire time horizon [T] (if existential) can arbitrarily exploit the non-eliminated mean rewards–every such reward is 𝒪(ε/2L)=𝒪(ε)-approximately optimal.

This elimination algorithm has two key features in each stage [0:L], which we call the accuracy guarantee 1 and the regret guarantee 1.

  • (MAB-AG) After stage , every non-eliminated mean reward is 𝒪(ε/2)-approximately optimal.

  • (MAB-RG) Stage accumulates at most 𝒪(ε/21)2/εK=𝒪(K/ε) regret.111More rigorously, the initial stage =0 requires a different deduction to the same regret bound 120/εK=𝒪(K/ε).

In combination, the total regret of this elimination algorithm is at most

[0:L]𝒪(K/ε)+T𝒪(ε/2L)=𝒪~(K/ε+Tε).

By choosing ε=Θ~(K/T), we achieve (nearly) optimal 𝒪~(KT) regret.

Elimination Algorithms for the Bilateral Trade Model.

In the bilateral trade model, it turns out that by considering the 1K-net of the entire action space {ai,j:=(iK,j1K)}i,j[K][0,1]2, at least one of the near-diagonal actions {ak,k}k[K] is a 1K-approximation to the benchmark action (p,q); we thus designate {ak,k}k[K] as the (initial) candidates and index them by 𝒞0:=[1:K].

If we could mechanically implement the above elimination algorithm for the standard MAB problem, then the total regret would be at most

𝒪~(K/ε+εT)=𝒪~(T2/3),

by choosing K=Θ~(ε1) and ε=Θ~(T1/3), which gives the desired regret bound.

Fractal elimination.

The standard elimination template suggests maintaining near-diagonal candidates ak,k and eliminating clearly suboptimal ones stage by stage. The obstacle is that, under one-bit feedback, playing a candidate itself does not provide an unbiased estimator for its GFT. A direct estimator queries separate polylines for different candidates and therefore incurs too much regret.

Our key idea is to reuse information across candidates. At each stage, the surviving candidates are enclosed by short diagonal segments. Around each segment, we query shared horizontal and vertical actions. By independence of the seller’s and buyer’s values, the desired GFT values can be reconstructed through recursive ratio decompositions. As the stages progress, the queried actions move exponentially closer to the diagonal, so their per-query regret diminishes. This simultaneously gives the accuracy invariant and the regret invariant needed for the O~(T2/3) bound. The full recursive implementation and concentration analysis appear in the full version.

Ingredient 2: A New Lower-Bound Construction, for Correlated Values

Our second main contribution is an Ω(T3/4) lower bound for GBB two-bit-feedback mechanisms in the “correlated values” setting, which improves the Ω(T5/7) lower bound obtained in [3, Theorem 5.5] for the same context and matches the 𝒪~(T3/4) upper bound obtained in [3, Theorem 5.4] even for more general contexts.

At a high level, the technical challenge is due in large part to the GBB constraint – it introduces relevance among different rounds – and the crux of our proof is a new remedy for it. For readability, let us first omit the GBB constraint and sketch a general lower-bound approach. Then, we will carefully compare the previous GBB remedy [3] and our new GBB remedy.

A General Lower-Bound Approach.

Basically, a regret lower bound requires constructing a family of hard-to-distinguish instances: When facing some instance from this family, a mechanism must determine its identity in the online learning process, namely “finding a needle in a haystack”.

To address our problem using this approach, we shall construct one base instance 𝒟0 and K1 hard instances {𝒟k}k[K] – recall that an instance is a [0,1]2-supported joint distribution. Each hard instance 𝒟k shall differ from the base instance 𝒟0 by some δ>0 in the total variation distance. As such, 𝒟k can simply perturb 𝒟0 by total probability mass of Θ(δ), distributed across constant number of actions, which forms the “needle”. The construction shall follow two criteria:

  • Information-Regret Dilemma: Each hard instance 𝒟k has a set of informative actions. Only those actions can provide information (on playing) that helps distinguish this hard instance 𝒟k, but each of them will incur constant regret Ω(1).

  • Disjointness: All hard instances {𝒟k}k[K] shall have disjoint sets of informative actions, thus no information sharing on individual plays of informative actions of different 𝒟k’s.

Given such a construction (if possible), we can informally reason about the total regret of a mechanism as follows:

  • If all individual hard instances {𝒟k}k[K] are distinguishable from the base instance 𝒟0, given the total variation distances of δ, this necessitates Ω(δ2) number of plays of a single 𝒟k’s informative actions and thus Ω(Kδ2) number of such plays altogether (Disjointness). However, then, we will suffer from Ω(Kδ2) total regret (Information-Regret Dilemma).

  • Otherwise, some hard instances 𝒟k are indistinguishable, and (roughly speaking) we will suffer from Ω(δT) total regret when facing one of them.

By choosing δ=K1/3T1/3, any mechanism will incur total regret

min{Ω(Kδ2),Ω(δT)}=Ω(K1/3T2/3). (1)

Consequently, proving an optimal lower bound reduces to the task of seeking a construction that has the largest possible K1 and, simultaneously, retains the above criteria.

It remains to determine the bottleneck of K1. Since each hard instance 𝒟k for k[K] needs to perturb the base instance 𝒟0 by total probability mass of Θ(δ) (planting a “mass-δ needle”), and these perturbations are “disjoint”, we naturally require K=𝒪(δ1). So if a construction can satisfy K=Θ(δ1), plugging this into Equation 1 directly gives an Ω(T3/4) lower bound, as desired.

To implement the above general approach in practice, however, the technical challenge is due in large part to the GBB constraint. As we quote from [3]:

“This (the GBB constraint) considerably complicates the construction of the hard instances, as any algorithm could sacrifice some profit temporarily by posting prices with Pt>Qt to extract a large Gains from Trade.”

The previous work [3] and our work will adopt very different remedies for the GBB constraint.

The Previous GBB Remedy.

The previous work [3] circumvents the GBB constraint in an ingenious manner. Their base instance 𝒟0 (see Figure 1(a) for a diagram) involves, just below the diagonal, value points “so bad” that even a single action play on their lower right side will incur intolerable regret.
These value points refer to grey points 𝒱4 in Figure 1(a). Further, “so bad” means the GFT-decrease due to a single such value point even dominates the total GFT-increase due to all other value points vertically above it.
This automatically forces a regret-optimal mechanism to satisfy the GBB constraint. In other words, central to their lower-bound construction is such a more “qualitative” principle:

Sacrifice of profit cannot produce extra Gains from Trade.

As it turns out, there are as many “so bad” value points as the hard instances (K1), and they each have probability mass Ω(Kδ). Then, it can be shown that K=Θ(δ1/2). Plugging this in Equation 1 gives an Ω(T5/7) lower bound [3, Theorem 5.5].

(a) The previous construction.
(b) Our new construction.
Figure 1: Diagrams of the previous Ω(T5/7) lower-bound construction [3, Theorem 5.5] and our new Ω(T3/4) lower-bound construction (Theorem 6).

Our New GBB Remedy.

Here, our contribution is a more careful treatment of the GBB constraint instead of simply circumventing it like [3]. Specifically, instead of incorporating “so bad” value points into the base instance 𝒟0, our lower-bound construction derives from a more “quantitative” principle:

Sacrifice of profit (“investment”) can produce extra Gains from Trade (“return”).
Just, the “return on investment” is not worthy enough for regret minimization.

This means a regret-optimal mechanism must abandon “investment” and, thus, restrict its action plays to the upper left side of the diagonal. In this manner, our more “quantitative” principle reaches the same goal – the GBB constraint – as the more “qualitative” principle by [3]. Technically, our principle is also more flexible for lower-bound construction, which enables us to construct K=Θ(δ1) many hard instances (while retaining the mentioned criteria) and thus show an Ω(T3/4) lower bound.

We have developed new techniques to implement the above discussions into a formal proof. In particular, we introduce a new constraint called Global Price Balance, given by

𝔼[t[T](QtPt)] 0.

Under our lower-bound construction, this new constraint turns out to be a consequence/relaxation of the original GBB constraint – every GBB mechanism must satisfy it – and is relatively easier to manipulate. Indeed, our Ω(T3/4) lower bound holds “more generally” for any mechanism that satisfies this new constraint; see Section 4 for details.

1.2 Concurrent Works [11, 10, 9]

Concurrent and independent works studied closely related questions. In particular, [11] independently introduced a feedback model equivalent to our semi feedback, while [10] independently proved a matching Ω(T3/4) lower bound for GBB partial-feedback mechanisms in the correlated/adversarial settings using a different construction. The recent work [9] studies the related profit-maximization objective.

2 Notations and Preliminaries

Given two nonnegative integers mn0, define the sets [n:m]:={n,n+1,,m1,m} and [n]:=[1:n]={1,2,,n}. Given a (possibly random) event , let 𝟙[]{0,1} be the indicator function. Also, given a real number x, let [x]+:=max{x,0}.

Repeated Bilateral Trade.

Our model involves a T-round222Throughout this work, we fix T1 as a sufficiently large integer. repeated game against an (oblivious) adversary: In each round t[T], a (new) seller and a (new) buyer seek to trade an indivisible item, which has value St to the seller and value Bt to the buyer. We aim to maximize the economic efficiency by designing a (repeated) mechanism that, ideally, enables trade whenever StBt. However, the adversary controls the value generation (St,Bt)t[T]; there are three classic models, listed below from the most to the least general.

  • Adversarial Values: The adversary determines an (arbitrary) 2T-dimensional [0,1]2T-supported joint distribution 𝒟; then, the values (St,Bt)t[T] across all rounds are drawn from it.

  • Correlated Values: The adversary determines an (arbitrary) two-dimensional [0,1]2-supported joint distribution 𝒟; then, the values (St,Bt) in each round t[T] are drawn i.i.d. from it.

  • Independent Values: This is identical to “correlated values”, except that 𝒟 is further required to be a product distribution 𝒟S𝒟B, making all the 2T values (St,Bt)t[T] mutually independent.

Some of our lower bounds hold even under the density-boundedness assumption, which was introduced to the repeated bilateral trade model by [5]. Clearly, this can only strengthen our hardness results.

Assumption 1 (Density Boundedness [5]).

Parameterized by M1, a joint distribution 𝒟 satisfies the density-boundedness assumption when its joint density function is upper-bounded by M.

Fixed-Price Mechanisms.

A fixed-price mechanism =(Pt,Qt)t[T] posts two possibly randomized prices in each round t[T], one for the seller Pt and one for the buyer Qt. A trade occurs when both agents accept their respective prices. This yields the Gains from Trade GFT(St,Bt,Pt,Qt) and the profit Profit(St,Bt,Pt,Qt), t[T]:

GFT(St,Bt,Pt,Qt) :=(BtSt)𝟙[StPt]𝟙[QtBt],
Profit(St,Bt,Pt,Qt) :=(QtPt)𝟙[StPt]𝟙[QtBt].

For notational brevity, we often simply write GFTt=GFT(St,Bt,Pt,Qt) when the values (St,Bt) and the prices (Pt,Qt) are clear from the context; such conventions extend to other notations.

When no ambiguity arises, we use the term mechanisms to refer to fixed-price mechanisms. A mechanism is initially ignorant of the underlying joint distribution 𝒟 and the values (St,Bt)t[T]𝒟, but receives certain feedback at the end of each round t[T]; given the past prices (Pr,Qr)r[t] and the past feedback, it proceeds to the next round t+1 and computes the prices (Pt+1,Qt+1). There are three natural feedback models, listed below from the most to the least informative.

  • Full Feedback: (St,Bt)[0,1]2 reveals both agents’ values.

  • Semi Feedback: This consists of four specific types:

    • (St,Yt)[0,1]×{0,1} reveals the seller’s value St and the buyer’s intention to trade Yt=Y(Bt,Qt):=𝟙[QtBt].

    • (Xt,Bt){0,1}×[0,1] reveals the seller’s intention to trade Xt=X(St,Pt):=𝟙[StPt] and the buyer’s value Bt.

    • (St,Zt)[0,1]×{0,1} reveals the seller’s value St and the trade outcome Zt=Z(St,Bt,Pt,Qt):=𝟙[StPtQtBt]XtYt.

    • (Zt,Bt){0,1}×[0,1] reveals the trade outcome ZtXtYt and the buyer’s value Bt.

  • Partial Feedback: This consists of two specific types:

    • Two-Bit Feedback: (Xt,Yt){0,1}2 reveals both agents’ intentions to trade.

    • One-Bit Feedback: ZtXtYt{0,1} reveals the trade outcome.

Previous works [5, 2, 3] have already acquired a thorough understanding of “full feedback”, so we concentrate on “semi feedback” and “partial feedback” in this work.

For the sake of economic viability, we further impose the Budget Balance (BB) constraint. There are two notions, a stricter Local Budget Balance (LBB) constraint [12] and a looser Global Budget Balance (GBB) constraint [3].

  • Local Budget Balance: This can be further differentiated into a stricter Strong Budget Balance (SBB) constraint and a looser Weak Budget Balance (WBB) constraint.

    • Strong Budget Balance: Profitt=0 (or essentially Pt=Qt), t[T].

    • Weak Budget Balance: Profitt0 (or essentially PtQt), t[T].

  • Global Budget Balance: t[T]Profitt0.

To summarize the scope of this work, there are 3×3×2=18 specific contexts. After omitting the well-understood “adversarial values” and “full feedback”, 2×2×2=8 contexts remain. In this proceedings version, we focus on the contexts needed for our main positive and negative results; the remaining auxiliary lower-bound statements are deferred to the full version.

Regret Minimization.

We evaluate the economic efficiency of a fixed-price mechanism within the regret minimization framework.

Over the entire repeated game, this mechanism induces Total Gains from Trade GFT𝒟 in expectation (over all possible randomness (St,Bt)t[T]𝒟 and (Pt,Qt)t[T]). We compare this to Bayesian-Optimal Total Gains from Trade GFT𝒟, which refers to the optimal-in-expectation fixed prices (p,q) with respect to the underlying joint distribution 𝒟.

GFT𝒟 :=𝔼(St,Bt)t[T]𝒟,(Pt,Qt)t[T][t[T]GFT(St,Bt,Pt,Qt)],
GFT𝒟 :=max0p=q1𝔼(St,Bt)t[T]𝒟[t[T]GFT(St,Bt,p,q)].

Without ambiguity, we often write 𝔼𝒟[]=𝔼(St,Bt)t[T]𝒟[] etc for notational brevity.

For a mechanism , we can define its (worst-case) regret Regret by taking into account all possible joint distributions 𝒟. In this regard, we aim to find the minimax regret Regret by designing a regret-optimal mechanism.

Regret :=max𝒟(GFT𝒟GFT𝒟),
Regret :=minRegret.

We will also use Regret𝒟:=GFT𝒟GFT𝒟 to denote the regret of on a specific distribution 𝒟. When is clear from the context, we may drop it from the superscript.

3 𝓞~(𝑻𝟐/𝟑) Partial-Feedback Upper Bound for Independent Values

In this section, we examine the power of “fixed-price mechanisms with the Global Budget Balance (GBB) constraint and one-bit feedback” in the “independent values” setting. Specifically, we will establish (Theorem 1) the following algorithmic result.

Theorem 1 (GBB One-Bit-Feedback Upper Bound for Independent Values).

In the “independent values” setting, there is a “GBB one-bit-feedback fixed-price mechanism” achieving 𝒪~(T2/3) regret.

Later in Appendix A, up to polylogarithmic factors, we will establish (Theorem 11) a matching lower bound (even if one-bit feedback is replaced by the more informative semi feedback).

In the literature, only a trivial 𝒪~(T3/4) upper bound and a trivial Ω(T1/2) lower bound were known – the upper bound is an implication from [3, Theorem 5.4] for “one-bit feedback, adversarial values”, and the lower bound is an implication from Theorem 12 for “full feedback, independent values”. Nonetheless, our algorithmic result here and our hardness result later in Theorem 11 together close the gap.

3.1 Mechanism Design

Our fixed-price mechanism, called GBB-OneBit and presented in Algorithm 1, is built on the mechanism design framework proposed by [3, Section 3]. This fixed-price mechanism has three phases:
Phase 1 invokes a subroutine, called ProfitMax and depicted in Proposition 3, which takes actions only from the upper-left action halfspace {(p,q)[0,1]2|pq}, thus nonnegative profit 0 per round. The main purpose of this phase is to accumulate sufficient profit, say Ω~(T2/3), while just incurring tolerable regret, say 𝒪~(T2/3). Regarding the GBB constraint, this cumulative profit makes mechanism design in subsequent phases more flexible.

Algorithm 1 GBB-OneBit.

Phase 2 invokes a subroutine, called FractalElimination and shown in Algorithm 2, which takes actions only from the lower-right action halfspace {(p,q)[0,1]2|p>q}, thus nonpositive profit 0 per round. Concretely, this subroutine begins with a set of K=Θ~(T1/3) many candidate nearly GFT-optimal actions (or candidates in short) indexed by 𝒞0=[1:K]; the GFT-optimal candidate is ensured to be a good enough approximation to the GFT-optimal action (p,q)[0,1]2 in the whole action space. The subroutine works in L+1log(K) many stages; a single stage [0:L] leverages one-bit feedback to distinguish the survival candidates 𝒞 hitherto (by taking actions from not only 𝒞 themselves, but also other actions in the lower-right action halfspace ), obtaining a more accurate location 𝒞+1𝒞 of the optimal candidate. After all the L+1log(K) many stages, the ultimate candidates 𝒞L+1 all will be good enough, compared even with the optimal action (p,q)[0,1]2 in the whole action space.
Phase 3 simply exploits the ultimate candidates 𝒞L+1, in an arbitrary manner.
Remarkably, as it turns out, Phases 2 and 3 never exhaust the profit accumulated in Phase 1, so the whole fixed-price mechanism GBB-OneBit satisfies the GBB constraint.

Preliminaries.

Our fixed-price mechanism GBB-OneBit will use the following parameters. Specifically, both subroutines ProfitMax and FractalElimination will use the discretization parameter K, only the former will use the profit threshold β, and only the latter will use the others L, δ, and γ’s.

K :=18T1/3log2/3(T), (the discretization parameter)
β := 9T2/3log2/3(T), (the profit threshold)
L :=13log(T), (the number of stages)
𝒞0 :=[1:K], (for initialization)
δ :=T4/3log1/3(T), (for confidence levels)
γ := 2/2K1/2+(61)K1, [0:L+1]. (for confidence intervals)

In expectation over the randomness of values (S,B)𝒟S𝒟B, an action (p,q)[0,1]2 induces (expected) Gains from Trade GFT(p,q), (expected) profit Profit(p,q), and (expected) regret Regret(p,q). It is easy to see that these formulae are [0,1]-valued.

GFT(p,q) :=𝔼(S,B)𝒟S𝒟B[GFT(S,B,p,q)], (p,q)[0,1]2,
Regret(p,q) :=(max0pq1GFT(p,q))GFT(p,q), (p,q)[0,1]2,
Profit(p,q) :=𝔼(S,B)𝒟S𝒟B[Profit(S,B,p,q)]
=(qp)𝒟S(p)(1𝒟B(q)), (p,q)[0,1]2.

Here we abuse notation: 𝒟S(p):=S𝒟S[Sp] and 𝒟B(q):=1B𝒟B[Bq]=B𝒟B[B<q] denote the corresponding cumulative distribution functions (CDF’s).

The following Lemma 2 shows a useful decomposition of the formula GFT(p,q).

Lemma 2 (Gains from Trade for Independent Values).

In the “independent values” settings,

GFT(p,q) =H(p,q)+V(p,q)+Profit(p,q), (p,q)[0,1]2.

Here the terms H(p,q):=0p𝒟S(x)dx(1𝒟B(q)) and V(p,q):=𝒟S(p)q1(1𝒟B(y))dy.

In addition, we recall that one-bit feedback Zt=Z(St,Bt,Pt,Qt){0,1} reveals whether or not the trade succeeded in a single round t[T].

Z(St,Bt,Pt,Qt)=𝟙[StPt]𝟙[QtBt].

The Subroutine ProfitMax.

To understand the performance guarantees of our fixed-price mechanism GBB-OneBit, all we need to know about (Phase 1 of GBB-OneBit) the subroutine ProfitMax can be summarized into the following Proposition 3, which is quoted (or, indeed, slightly rephrased) from [3, Lemma 5.1].333This fixed-price mechanism ProfitMax is built on the EXP3.P learning algorithm by [1]; its performance guarantees given in Proposition 3 were shown by [3, Lemma 5.1] for “adversarial values”, which accommodates “independent values”. As mentioned, the purpose of ProfitMax is to accumulate sufficient profit (at the cost of tolerable regret), making mechanism design in subsequent phases more flexible. For detailed implementation of ProfitMax, the interested reader can reference [3, Sections 3 and 5].

Proposition 3 ([3, Lemma 5.1]).

There exists a fixed-price mechanism ProfitMax(K,β) with one-bit feedback, on input a discretization parameter K1 and a profit threshold β>0, such that:

  1. 1.

    It takes actions {(Pt,Qt)}t=1,2, only from a size-|K|=2K(log(T)+1) discrete subset K{(p,q)[0,1]2|pq} of the upper-left action halfspace.
    Thus, the per-round profit is nonnegative Profit(St,Bt,Pt,Qt)0, t=1,2,, almost surely.

  2. 2.

    It terminates at the end of some round T[T], which has two possibilities:
    (i) T[T] is the first round such that t[T]Profit(St,Bt,Pt,Qt)β, if existential.
    (ii) T=T, if t[T]Profit(St,Bt,Pt,Qt)<β.
    In either case, with probability 1T1, the cumulative regret t[T]Regret(Pt,Qt) satisfies that

    t[T]Regret(Pt,Qt)(8β+8)log(T)+5TK+256T|K|log(T|K|)log(T).
Corollary 4 (ProfitMax; Instantiation).

In the context of Proposition 3, set KK and ββ. Then in either case, with probability 1T1, the cumulative regret t[T]Regret(Pt,Qt)220T2/3log5/3(T).

In the rest of Section 3, we would call the subroutine ProfitMax “successful” if its cumulative regret satisfies the bound t[T]Regret(Pt,Qt)220T2/3log5/3(T) given in Corollary 4, or “failed” otherwise.

The Subroutine FractalElimination.

Based on the profit accumulated above (β=Θ~(T2/3), say), our fixed-price mechanism GBB-OneBit (Phase 2 thereof) then invokes the subroutine FractalElimination to distinguish the optimal action a=(p,q)[0,1]2, or rather, its good enough approximations, while preserving the GBB constraint.

Now let us elaborate on this subroutine FractalElimination; see Algorithm 2 for its implementation and Figure 2 for a diagram. Before all else, we use our discretization parameter K=Θ~(T2/3) to construct the following 1K-net {ai,j}1i,jK of the whole action space [0,1]2 (yet FractalElimination only takes actions from the lower-right half {ai,j}1jiK). Among these discrete actions, we designate {ak,k}k[1:K] as candidates of “good enough approximations to the optimal action a”; indeed, the optimal candidate aμ,μ (say) is a good enough 1K-approximation to the optimal action a.

ai,j :=(iK,j1K), 1i,jK.

In regard to discrete actions {ai,j}1i,jK and one-bit feedback Zt=𝟙[StPt]𝟙[QtBt]{0,1}, we define the trade rates {Zi,j}1i,jK as follows. It is easy to see that Zi,j[0,1] and the monotonicity Z1,jZi,jZK,j and Zi,1Zi,jZi,K.

Zi,j :=𝔼(S,B)𝒟S𝒟B[Z(S,B,ai,j)]
=𝒟S(iK)(1𝒟B(j1K)), 1i,jK. (2)

In regard to (Lemma 2) the decomposition GFT(p,q)=H(p,q)+V(p,q)+Profit(p,q), (p,q)[0,1]2, we define the following terms H~([σ:τ],j) and V~(i,[σ:τ]).

H~([σ:τ],j) :=1Ki[σ:τ]Zi,j, [σ:τ][1:K],j[1:K], (3)
V~(i,[σ:τ]) :=1Kj[σ:τ]Zi,j, [σ:τ][1:K],i[1:K]. (4)

It is easy to check that all these terms are [0,1]-bounded and, specifically, that H~([1:i],j)=H(ai,j)±K1 and V~(i,[j:K])=V(ai,j)±K1, 1i,jK. Moreover, every candidate k[1:K] induces negligible profit Profit(ak,k)=±K1.

Algorithm 2 FractalElimination(,[σ:τ],h,v).
Figure 2: Diagram of a specific stage [0:L] of the subroutine FractalElimination (Algorithm 2).
Here, ’s in general refer to candidates {ak,k}k[1:K], and ’s in particular refer to candidates {ak,k}k[1:K] eliminated in the current stage [0:L].
Also, the red horizontal/vertical lines aσ,σaτ,σ and aτ,σaτ,τ refer to actions taken in Line 2, and the six blue/green ’s (with aτ,σ counted twice) refer to actions taken in Lines 11 and 15.
When FractalElimination proceeds from the current stage [0:L] to the next stage +1[1:L+1], the considered segment [σ:τ] (and its associated red triangle) shrinks to two smaller segments [σ:τ] and [σ′′:τ′′] (and their associated blue/green triangles).

FractalElimination follows a divide-and-conquer principle and, over L+1log(K) stages, locates the optimal candidate aμ,μ more and more accurately. In more details:

Induction Hypothesis. Before a specific stage [0:L], we have already located aμ,μ in a candidate set 𝒞[1:K], and we have up to 2 many disjoint segments [σ:τ][1:K] whose union covers 𝒞. For every considered segment [σ:τ], estimates hH~([1:σ1],σ) and vV~(τ,[τ+1:K]) are good enough.

Base Case. Before the initial stage =0, we just consider a “universal” candidate set 𝒞0:=[1:K] and a single “universal” segment [σ:τ]=[1:K]. Therefore, (Phase 2 of GBB-OneBit) estimates h=0=H~(,σ)=H~([1:σ1],σ) and v=0=V~(τ,)=V~(τ,[τ+1:K]) are perfect.

Induction Step. In a specific stage [0:L], we aim at locating aμ,μ more accurately 𝒞+1𝒞, by leveraging one-bit feedback, and retain Induction Hypothesis for the next stage +1[1:L+1].

For every considered segment [σ:τ] (cf. the two red ’s in Figure 2), we can obtain (Lines 2 and 3) the following good enough estimates for trade rates {Zi,σ}i[σ:τ]{Zτ,j}j[σ:τ] (cf. the red horizontal/vertical lines in Figure 2).

Z^i,σ Zi,σ, i[σ:τ],
Z^τ,j Zτ,j, j[σ:τ].

Also, for these candidates [σ:τ], especially the survival ones k𝒞[σ:τ], we can obtain (Lines 4 and 5) the following good enough estimates for terms H~([σ:k],σ) and V~(τ,[k:τ]).

H^([σ:k],σ) =1Ki[σ:k]Z^i,σH~([σ:k],σ), k𝒞[σ:τ],
V^(τ,[k:τ]) =1Kj[k:τ]Z^τ,jV~(τ,[k:τ]), k𝒞[σ:τ].

Provided that (Induction Hypothesis) estimates hH~([1:σ1],σ) and vV~(τ,[τ+1:K]) are also good enough, we can add either of them to the above ones, thus good enough estimates for terms H~([1:k],σ)=H(ak,σ)±K1 and V~(τ,[k:K])=V(aτ,k)±K1, k𝒞[σ:τ]. In regard to the independence of values (S,B)𝒟S𝒟B and that a candidate ak,k always induces negligible profit Profit(ak,k)=±K1, we can obtain (Lemma 2 and Line 3) the following good enough estimates GFT^[k]GFT(ak,k) for Gains from Trade from survival candidates k𝒞[σ:τ] in the considered segment.

GFT^[k] =(h+H^([σ:k],σ))Z^τ,kZ^τ,σ+(v+V^(τ,[k:τ]))Z^k,σZ^τ,σ
H~([1:K],σ)Zτ,kZτ,σ+V~(τ,[k:K])Zk,σZτ,σ
H(ak,k)+V(ak,k)
GFT(ak,k)

Over all of the up to 2 many disjoint segments [σ:τ], whose union covers 𝒞 (Induction Hypothesis), we do obtain good enough estimates GFT^[k]GFT(ak,k), for all survival candidates k𝒞 in the current stage [0:L]. Then, we do locate (Line 7) the optimal candidate aμ,μ more accurately 𝒞+1𝒞.

Moreover, we need to retain Induction Hypothesis for the next stage +1[1:L+1]. To this end, we simply follow the divide-and-conquer principle:
(Lines 8 and 9) For every considered segment [σ:τ], find two disjoint half-segments [σ:τ] and [σ′′:τ′′] to cover the new survival candidates 𝒞+1[σ:τ] therein (cf. the two blue ’s and the two green ’s in Figure 2). Clearly, there are up to 2+1 many such half-segments in total, and their union covers the new candidate set 𝒞+1.
(Lines 11 to 13 and 15 to 17) For every half-segment [σ:τ], i.e., a new segment for the next stage +1[1:L+1], obtain new good enough estimates hH~([1:σ1],σ) and vV~(τ,[τ+1:K]), in a similar manner as the above; similarly for every other half-segment [σ′′:τ′′].
(Lines 14 and 18) Move on to the next stage +1[1:L+1].

In sum, initially there are |𝒞0|=K=Θ~(T2/3) many candidates. After all the L+1log(K) many stages, the ultimate candidates 𝒞L+1 all will be good enough, compared with the optimal candidate aμ,μ or even the optimal action a in the whole action space.

Proposition 5 (FractalElimination Guarantee, Informal).

For K=Θ~(T1/3), the subroutine FractalElimination uses one-bit feedback and, with high probability, returns a candidate ak,k whose expected gains from trade is within O~(T1/3) of the optimal fixed price. Moreover, during the subroutine, the total regret and the total budget deficit are both bounded by O~(T2/3).

The proof proceeds by a stage-wise elimination argument. At each stage, the remaining candidates lie on short diagonal segments. Instead of estimating each candidate separately, the algorithm queries carefully chosen horizontal and vertical segments so that many candidates share the same observations. The independence of S and B allows us to express the required GFT estimates through products of ratios, obtained recursively from one-bit feedback. This yields both the accuracy invariant and the regret invariant. The full induction and concentration bounds are deferred to the full version.

3.2 Performance Analysis

Proof sketch of Theorem 1.

Phase 1 invokes ProfitMax to accumulate Ω~(T2/3) budget surplus while incurring O~(T2/3) regret. Phase 2 invokes FractalElimination; by Proposition 5, it identifies an O~(T1/3)-optimal diagonal candidate while spending only the surplus accumulated in Phase 1. Phase 3 exploits any remaining candidate. Combining the regret from the three phases gives O~(T2/3), and the budget surplus from Phase 1 ensures GBB.

4 𝛀(𝑻𝟑/𝟒) Partial-Feedback Lower Bound for Correlated Values

In this section, we study the limit of “fixed-price mechanisms with the Global Budget Balance (GBB) constraint and partial feedback” in the “correlated values” setting. Specifically, we will establish (Theorem 6) the following hardness result. By implication, the same lower bound extends to the more general “adversarial values” setting.

Theorem 6 (GBB Partial-Feedback Lower Bound for Correlated Values).

In the “correlated values” setting (with or without the density-boundedness assumption – Assumption 1 with parameter M=224),

every “GBB fixed-price mechanism with two-bit feedback” has worst-case regret Ω(T3/4).

Previously, in both the “correlated values” setting and the “adversarial values” setting, merely an 𝒪~(T3/4) upper bound [3, Theorem 5.4] and an unmatching Ω(T5/7) lower bound [3, Theorem 5.5] were known. Nonetheless, our hardness result closes this gap by (up to polylogarithmic factors) establishing a matching Ω(T3/4) lower bound.

We will only establish the “discrete values” version of Theorem 6 in Sections 4.1 and 4.2; the “density-bounded values” version can be found in the full version.

4.1 Lower-Bound Construction for Discrete Values

Our construction utilizes two parameters K=Θ(T1/4) and δ=Θ(T1/4), as follows.

K :=T1/4,
δ :=0.15K+2.

The Value Support.

We will construct (K+1) base/hard instances {𝒟k}k[0:K], which have a common discrete support 𝒱[0,1]2, including four types of points that serve different purposes – a size-(3K+1) “upper-left” subset 𝒱UL, a size-(2K+1) “lower-right” subset 𝒱LR, four “corner” points 𝒱cor={0,1}2, and one “majority” point vmaj=(0.4,0.6); see Figure 3(a) for a diagram.

𝒱 :=𝒱UL𝒱LR𝒱cor{vmaj},
𝒱UL :={(k5K, 0.4+k5K)}k[0:3K],
𝒱LR :={(0.2+k5K, 0.4+k5K)}k[0:2K],
𝒱cor :={0,1}2,
vmaj :=(0.4,0.6).

Note that the majority point vmaj is also the index-K point in the lower-right subset 𝒱LR[K]=(0.4,0.6); a base/hard instance 𝒟k assigns two probability masses to this point, one for vmaj and one for 𝒱LR[k]. However, we can safely treat it as two isolated points (or, interchangeably, treat it as one point by adding both probability masses together). All other points v𝒱\{vmaj} are isolated.

(a) The support 𝒱[0,1]2.
(b) The informative action subsets k.
Figure 3: Diagrams of our new Ω(T3/4) lower-bound construction (Theorem 6).

The Base/Hard Instances.

Among the K+1 instances, 𝒟0 is the base instance and is given as follows.

(S,B)𝒟0[(S,B)=v]:={δ,v𝒱UL𝒱LR0.1,v𝒱cor0.5,v=vmaj.

This 𝒟0 is a well-defined distribution, given that δ|𝒱UL𝒱LR|+0.1|𝒱cor|+0.5|{vmaj}|=1.

In contrast, each 𝒟k for k[K] is a hard instance and tweaks the probability masses at two upper-left points 𝒱UL[k1],𝒱UL[k] and two lower-right points 𝒱LR[k1],𝒱LR[k] (but otherwise is identical to the base instance 𝒟0); see Figure 3(b) for a diagram. Again, this 𝒟k is a well-defined distribution.

(S,B)𝒟k[(S,B)=v]:={(S,B)𝒟0[(S,B)=v]+δ,v{𝒱UL[k],𝒱LR[k1]}(S,B)𝒟0[(S,B)=v]δ,v{𝒱UL[k1],𝒱LR[k]}(S,B)𝒟0[(S,B)=v],otherwise.

4.2 Lower-Bound Analysis for Discrete Values

For the base/hard instances {𝒟k}k[0:K] above, we will establish an Ω(T3/4) lower bound in three steps:

  • Firstly, we show that a mechanism ’s actions (Pt,Qt)t[T], without loss of generality, can be restricted to a particular discrete set 𝒜 (or, more precisely, a (3K+1)×(3K+1) grid).

  • Secondly, we show that the Global Budget Balance constraint can be relaxed to another constraint (which we call Global Price Balance); the Ω(T3/4) lower bound holds even after this relaxation.

  • Thirdly, we establish an indistinguishability argument: any algorithm must take sufficiently many informative actions in order to distinguish between hard instances.

Step 1: Discretization of Actions

It turns out that a regret-optimal mechanism =(Pt,Qt)t[T] can take actions (Pt,Qt) only from 𝒜, the Cartesian product of the coordinate projections – excluding the “trivial” seller value of 1 and the “trivial” buyer value of 0 – of the support 𝒱[0,1]2; cf. the union of the red/green regions in Figure 3(a).

𝒜 :=(projS(𝒱)\{1})×(projB(𝒱)\{0})
={k5K}k[0:3K]×{0.4+k5K}k[0:3K].

The explicit transformation is provided in the full version.

Lemma 7 (Discretization of Actions).

A (generic) fixed-price mechanism ¯=(P¯t,Q¯t)t[T] can transform into a new fixed-price mechanism =(Pt,Qt)t[T] such that, in any possibility 𝒟=𝒟k for k[0:K]:

  • (Pt,Qt)t[T]𝒜, almost surely.

  • On the same realization (St,Bt)t[T]𝒟k, almost surely over the randomness of ¯ and ,
    both the Gains from Trade and the profit in every round t[T] can only increase:

    GFT(St,Bt,Pt,Qt) GFT(St,Bt,P¯t,Q¯t), t[T],
    Profit(St,Bt,Pt,Qt) Profit(St,Bt,P¯t,Q¯t), t[T].

In the rest of Section 4, we safely restrict actions to the discrete set 𝒜. To emphasize this, we rewrite 𝒜 for a mechanism . To proceed, we divide 𝒜 into a “good” subset 𝒢 (cf. the green region in Figure 3(a)) and a “bad” subset (cf. the red region in Figure 3(a)), as follows.

𝒢 :=k[0:K]𝒢k,
𝒢k :={(0.4+i5K, 0.4+k5K)}i[0:K], k[0:K],
:=𝒜\𝒢.

Let us denote by Regret𝒟(p,q) the regret incurred by each take of an action (p,q)𝒜=𝒢. The following Proposition 8 lower-bounds Regret𝒟(p,q) in each possibility 𝒟=𝒟k for k[0:K].

Proposition 8 (Gains from Trade).

For the base instance 𝒟0 and the hard instances 𝒟k, k[K]:

Regret𝒟0(p,q) {0.1,(p,q)3δK(qp),(p,q)𝒢,
Regret𝒟k(p,q) {0.1,(p,q)3δK(qp)+0.2δ𝟙[(p,q)𝒢k],(p,q)𝒢.

Step 2: Relaxation of Global Budget Balance

We now show that, under our lower-bound construction, a GBB mechanism 𝒜 always satisfies the following “Global Price Balance” condition; thus, it serves as a relaxation of the GBB constraint.

Lemma 9 (Relaxation of GBB).

For a GBB fixed-price mechanism 𝒜, in each possibility k[0:K]:

𝔼k[t[T](QtPt)] 0. (Global Price Balance)

Step 3: Indistinguishability Argument

Regarding each hard instance 𝒟k for k[K], we define its informative action subset k – only taking such actions can help in distinguishing this 𝒟k from the other base/hard instances. The following lemma states that any algorithm behaves similarly on instances 𝒟0 and 𝒟k, if the informative action subset k is explored only a sufficiently small number of times; we refer the reader to the full version for the explicit definition of k.

Lemma 10.

In each possibility k[K]:

𝔼k[T𝒢k]𝔼0[T𝒢k]T15δ2𝔼0[Tk]

Finally, we are ready to accomplish Theorem 6.

Proof of Theorem 6.

Recall that we divide 𝒜 into two disjoint subsets 𝒜=𝒢. For the base instance 𝒟0, each take of a bad action (Pt,Qt) incurs at least 0.1 regret, and each take of a good action (Pt,Qt)𝒢 incurs 3δK(QtPt) regret (Proposition 8), so the total regret is at least
Regret𝒟0 =𝔼0[t[T](𝟙[(Pt,Qt)]Regret𝒟0(Pt,Qt) +𝟙[(Pt,Qt)𝒢]Regret𝒟0(Pt,Qt))] Proposition 8 0.1𝔼0[T]+ 3δK𝔼0[t[T](QtPt)𝟙[(Pt,Qt)𝒢]] Lemma 9 and =𝒜\𝒢 0.1𝔼0[T] 3δK𝔼0[t[T](QtPt)𝟙[(Pt,Qt)]] QtPt1 0.1𝔼0[T] 3δK𝔼0[T] δK=0.1K5K+20.02 0.04𝔼0[T].

For each hard instance 𝒟k, k[K], a moment’s reflection will show that the deduction above for 𝒟0 still holds, and each take of an action (Pt,Qt)𝒢\𝒢k will incur 0.2δ more regret (Proposition 8). Thus, we can obtain

Regret𝒟k 0.04𝔼k[T]+𝔼k[t[T]0.2δ𝟙[(Pt,Qt)𝒢\𝒢k]]
= 0.04𝔼k[T]+ 0.2δ(𝔼k[T𝒢]𝔼k[T𝒢k])
Lemma 10 0.04𝔼k[T]+ 0.2δ(T𝔼k[T]𝔼0[T𝒢k]4δT𝔼0[Tk])
δ[0,120] 0.2δ(T𝔼0[T𝒢k]4δT𝔼0[Tk]).

Taking the average of Regret𝒟k’s for k[K] gives

1Kk[K]Regret𝒟k 1Kk[K]0.2δ(T𝔼0[T𝒢k]4δT𝔼0[Tk])
k[K]T𝒢kT (a.s.) 0.2δ(TTK4δTKk[K]𝔼0[Tk])
Cauchy-Schwarz inequality 0.2δ(TTK4δT1Kk[K]𝔼0[Tk])
k[K]Tk2T (a.s.) 0.2δ(TTK4δT2K𝔼0[T]).

Here the last step uses k[K]T𝒢kT, as a consequence of that 𝒢k’s for k[K] are disjoint. And the last step uses k[K]Tk2T.

Plugging in K=T1/4 and δ=0.15K+2, it is easy to verify through elementary algebra that

max{Regret𝒟0,1Kk[K]Regret𝒟k}
max{0.04𝔼0[T], 0.004T3/4(1T1/41+0.4T1/40.08(1+0.4T1/4)22𝔼0[T]T3/4)}
=Ω(T3/4).

In sum, the considered mechanism 𝒜 incurs Ω(T3/4) regret in at least one possibility k[0:K]. Then, the arbitrariness of 𝒜 implies Theorem 6.

References

  • [1] Peter Auer, Nicolò Cesa-Bianchi, Yoav Freund, and Robert E. Schapire. The nonstochastic multiarmed bandit problem. SIAM J. Comput., 32(1):48–77, 2002. doi:10.1137/S0097539701398375.
  • [2] Yossi Azar, Amos Fiat, and Federico Fusco. An α-regret analysis of adversarial bilateral trade. Artif. Intell., 337:104231, 2024. doi:10.1016/J.ARTINT.2024.104231.
  • [3] Martino Bernasconi, Matteo Castiglioni, Andrea Celli, and Federico Fusco. No-regret learning in bilateral trade via global budget balance. In Bojan Mohar, Igor Shinkar, and Ryan O’Donnell, editors, Proceedings of the 56th Annual ACM Symposium on Theory of Computing, STOC 2024, Vancouver, BC, Canada, June 24-28, 2024, pages 247–258. ACM, 2024. doi:10.1145/3618260.3649653.
  • [4] Avrim Blum, Tuomas Sandholm, and Martin Zinkevich. Online algorithms for market clearing. J. ACM, 53(5):845–879, 2006. doi:10.1145/1183907.1183913.
  • [5] Nicolò Cesa-Bianchi, Tommaso Cesari, Roberto Colomboni, Federico Fusco, and Stefano Leonardi. Bilateral trade: A regret minimization perspective. Math. Oper. Res., 49(1):171–203, 2024. doi:10.1287/MOOR.2023.1351.
  • [6] Nicolò Cesa-Bianchi, Tommaso Cesari, Roberto Colomboni, Federico Fusco, and Stefano Leonardi. Regret analysis of bilateral trade with a smoothed adversary. J. Mach. Learn. Res., 25:234:1–234:36, 2024. URL: https://jmlr.org/papers/v25/23-1627.html.
  • [7] Houshuang Chen, Yaonan Jin, Pinyan Lu, and Chihao Zhang. Tight regret bounds for fixed-price bilateral trade. arXiv preprint arXiv:2504.04349, 2025. doi:10.48550/arXiv.2504.04349.
  • [8] Shahar Dobzinski and Ariel Shaulker. Bilateral trade with correlated values. In Bojan Mohar, Igor Shinkar, and Ryan O’Donnell, editors, Proceedings of the 56th Annual ACM Symposium on Theory of Computing, STOC 2024, Vancouver, BC, Canada, June 24-28, 2024, pages 237–246. ACM, 2024. doi:10.1145/3618260.3649659.
  • [9] Simone Di Gregorio, Paul Dütting, Federico Fusco, and Chris Schwiegelshohn. Nearly tight regret bounds for profit maximization in bilateral trade. arXiv preprint arXiv:2509.22563, 2025. To appear in FOCS 2025. doi:10.48550/arXiv.2509.22563.
  • [10] Anna Lunghi, Matteo Castiglioni, and Alberto Marchesi. Better regret rates in bilateral trade via sublinear budget violation. arXiv preprint arXiv:2507.11419, 2025. To appear in SODA 2026. doi:10.48550/arXiv.2507.11419.
  • [11] Anna Lunghi, Matteo Castiglioni, and Alberto Marchesi. Online two-sided markets: Many buyers enhance learning. arXiv preprint arXiv:2503.01529, 2025. doi:10.48550/arXiv.2503.01529.
  • [12] Roger B Myerson and Mark A Satterthwaite. Efficient mechanisms for bilateral trading. Journal of economic theory, 29(2):265–281, 1983.
  • [13] William Vickrey. Counterspeculation, auctions, and competitive sealed tenders. The Journal of Finance, 16(1):8–37, 1961. doi:10.1111/j.1540-6261.1961.tb02789.x.

Appendix A Additional Lower Bounds

Theorem 11 (GBB Semi-Feedback Lower Bound for Independent Values).

In the “independent values” setting (with or without the density-boundedness assumption – Assumption 1 with parameter M=11), every “GBB semi-feedback fixed-price mechanism” has worst-case regret Ω(T2/3).

Theorem 12 (GBB Full-Feedback Lower Bound for Independent Values).

In the “independent values” setting (with or without the density-boundedness assumption – Assumption 1 with parameter M=11),

every “GBB full-feedback fixed-price mechanism” has worst-case regret Ω(T1/2).

Theorem 13 (WBB Partial-Feedback Lower Bound for Independent Values [5, Theorem 6]).

In the “independent values” setting, every “WBB fixed-price mechanism with two-bit feedback” has worst-case regret Ω(T).