Machine Learning-Powered Combinatorial Clock Auction

Abstract

We study the design of iterative combinatorial auctions (ICAs). The main challenge in this domain is that the bundle space grows exponentially in the number of items. To address this, several papers have recently proposed machine learning (ML)-based preference elicitation algorithms that aim to elicit only the most important information from bidders. However, from a practical point of view, the main shortcoming of this prior work is that those designs elicit bidders' preferences via value queries (i.e., ``What is your value for the bundle {A,B}\{A,B\}?''). In most real-world ICA domains, value queries are considered impractical, since they impose an unrealistically high cognitive burden on bidders, which is why they are not used in practice. In this paper, we address this shortcoming by designing an ML-powered combinatorial clock auction that elicits information from the bidders only via demand queries (i.e., ``At prices p, what is your most preferred bundle of items?''). We make two key technical contributions: First, we present a novel method for training an ML model on demand queries. Second, based on those trained ML models, we introduce an efficient method for determining the demand query with the highest clearing potential, for which we also provide a theoretical foundation. We experimentally evaluate our ML-based demand query mechanism in several spectrum auction domains and compare it against the most established real-world ICA: the combinatorial clock auction (CCA). Our mechanism significantly outperforms the CCA in terms of efficiency in all domains, it achieves higher efficiency in a significantly reduced number of rounds, and, using linear prices, it exhibits vastly higher clearing potential. Thus, with this paper we bridge the gap between research and practice and propose the first practical ML-powered ICA.

Full text

Machine Learning-Powered Combinatorial Clock Auction
Ermis Nikiforos Soumalias1,3†,Jakob Weissteiner1,3†,Jakob Heiss2,3,Sven Seuken1,3
1University of Zurich
2ETH Zurich
3ETH AI Center
ermis@ifi.uzh.ch, weissteiner@ifi.uzh.ch, jakob.heiss@math.ethz.ch, seuken@ifi.uzh.ch
Abstract
We study the design of iterative combinatorial auctions
(ICAs). The main challenge in this domain is that the bun-
dle space grows exponentially in the number of items. To
address this, several papers have recently proposed machine
learning (ML)-based preference elicitation algorithms that
aim to elicit only the most important information from bid-
ders. However, from a practical point of view, the main short-
coming of this prior work is that those designs elicit bid-
ders’ preferences via value queries (i.e., “What is your value
for the bundle {A, B}?”). In most real-world ICA domains,
value queries are considered impractical, since they impose
an unrealistically high cognitive burden on bidders, which is
why they are not used in practice. In this paper, we address
this shortcoming by designing an ML-powered combinatorial
clock auction that elicits information from the bidders only
via demand queries (i.e., “At prices p, what is your most pre-
ferred bundle of items?”). We make two key technical con-
tributions: First, we present a novel method for training an
ML model on demand queries. Second, based on those trained
ML models, we introduce an efficient method for determin-
ing the demand query with the highest clearing potential, for
which we also provide a theoretical foundation. We experi-
mentally evaluate our ML-based demand query mechanism
in several spectrum auction domains and compare it against
the most established real-world ICA: the combinatorial clock
auction (CCA). Our mechanism significantly outperforms the
CCA in terms of efficiency in all domains, it achieves higher
efficiency in a significantly reduced number of rounds, and,
using linear prices, it exhibits vastly higher clearing potential.
Thus, with this paper we bridge the gap between research and
practice and propose the first practical ML-powered ICA.
1 Introduction
Combinatorial auctions (CAs) are used to allocate multi-
ple items among several bidders who may view those items
as complements or substitutes. In a CA, bidders are al-
lowed to submit bids over bundles of items. CAs have en-
joyed widespread adoption in practice, with their applica-
tions ranging from allocating spectrum licences (Cramton
2013) to TV ad slots (Goetzendorff et al. 2015) and airport
landing/take-off slots (Rassenti, Smith, and Bulfin 1982).
*This paper is the full version of Soumalias et al. (2024) pub-
lished at AAAI’24 including the appendix.
†These authors contributed equally.
One of the key challenges in CAs is that the bundle space
grows exponentially in the number of items, making it in-
feasible for bidders to report their full value function in all
but the smallest domains. Moreover, Nisan and Segal (2006)
showed that for general value functions, CAs require an ex-
ponential number of bids in order to achieve full efficiency
in the worst case. Thus, practical CA designs cannot pro-
vide efficiency guarantees in real world settings with more
than a modest number of items. Instead, the focus has shifted
towards iterative combinatorial auctions (ICAs), where bid-
ders interact with the auctioneer over a series of rounds, pro-
viding a limited amount of information, and the aim of the
auctioneer is to find a highly efficient allocation.
The most established mechanism following this interac-
tion paradigm is the combinatorial clock auction (CCA)
(Ausubel, Cramton, and Milgrom 2006). The CCA has
been used extensively for spectrum allocation, generating
over $20 Billion in revenue between 2012 and 2014 alone
(Ausubel and Baranov 2017). Speed of convergence is a crit-
ical consideration for any ICA since each round can entail
costly computations and business modelling for the bidders
(Kwasnica et al. 2005;Milgrom and Segal 2017;Bichler,
Hao, and Adomavicius 2017). Large spectrum auctions fol-
lowing the CCA format can take more than 100 bidding
rounds. In order to decrease the number of rounds, many
CAs in practice use aggressive price update rules (e.g., in-
creasing prices by up to 10% each round), which can harm
efficiency (Ausubel and Baranov 2017). Thus, it remains a
challenging problem to design a practical ICA that elicits in-
formation via demand queries, is efficient, and converges in
a small number of rounds. Specifically, given the value of re-
sources allocated in such real-world ICAs, increasing their
efficiency by even one percentage point already translates
into monetary gains of hundreds of millions of dollars.
1.1 ML-Powered Preference Elicitation
To address this challenge, researchers have proposed vari-
ous ways of using machine learning (ML) to improve the
efficiency of CAs. The seminal works by Blum et al. (2004)
and Lahaie and Parkes (2004) were the first to frame pref-
erence elicitation in CAs as a learning problem. In the
same strand of research, Brero, Lubin, and Seuken (2018,
2021), Weissteiner and Seuken (2020) and Weissteiner et al.
(2022b) proposed ML-powered ICAs. At the heart of those
1

approaches lies an ML-powered preference elicitation algo-
rithm that uses an ML model to approximate each bidder’s
value function and to generate the next value query, which
in turn refines that bidder’s model. Weissteiner et al. (2022a)
designed a special network architecture for this framework
while Weissteiner et al. (2023) incorporated a notion of un-
certainty (Heiss et al. 2022) into the framework, further in-
creasing its efficiency. Despite their great efficiency gains
compared to traditional CA designs, those approaches suf-
fer from one common limitation: they fundamentally rely
on value queries of the form “What is your value for bundle
{A, B}”. Prior research in auction design has identified de-
mand queries (DQs) as the best way to run an auction (Cram-
ton 2013). Their advantages compared to value queries in-
clude elimination of tacit collusion and bid signaling, as well
as simplified bidder decision-making that keeps the bidders
focused on what is most relevant: the relationship between
prices and aggregate demand. Additionally, value queries are
cognitively more complex, and thus typically impractical for
real-world ICAs. For these reasons, DQs are the most promi-
nent interaction paradigm for auctions in practice.
Despite the prominence of DQs in real-world applica-
tions, the only prior work on ML-based DQs that we are
aware of is that of Brero and Lahaie (2018) and Brero, La-
haie, and Seuken (2019), who proposed integrating ML in
a price-based ICA to generate the next price vector in or-
der to achieve faster convergence. Similar to our design,
in these works the auctioneer maintains a model of each
agent’s value function, which are updated as the agents bid
in the auction and reveal more information about their val-
ues. Then, those models are used in each round to com-
pute new prices and drive the bidding process. Unlike our
approach, the design of this prior work focuses solely on
clearing potential, as the authors do not report efficiency re-
sults. Additionally, their design suffers from some signifi-
cant limitations: (i) it does not exploit any notion of simi-
larity between bundles that contain overlapping items, (ii) it
only incorporates a fraction of the information revealed by
the agents’ bidding. Specifically, it only makes use of the
fact that for the bundle an agent bids on, her value for that
bundle must be larger than its price, and (iii) their approach
is computationally intractable already in medium-sized auc-
tion domains, as their price update rule requires a large num-
ber lof posterior samples for expectation maximization and
then solving a linear program whose number of constraints
for each bidder is proportional to ltimes the number of bids
by that agent. These limitations are significant, as they can
lead to large efficiency decreases in complex combinatorial
domains. Moreover, their design cannot be easily modified
to alleviate these limitations. In contrast, our approach effec-
tively addresses all of these limitations.
1.2 Our Contributions
In this paper, we address the main shortcomings of prior
work by designing an ML-powered combinatorial clock auc-
tion. Our auction elicits information from bidders via de-
mand queries (DQs) instead of value queries, while simulta-
neously, unlike prior work on ML-based DQs, being com-
putationally feasible for large domains and incorporating
the complete information the demand query observations
provide into the training of our ML models. Concretely,
we use Monotone-Value Neural Networks (MVNNs) (Weis-
steiner et al. 2022a) as ML models, which are tailored to
model monotone and non-linear combinatorial value func-
tions in CAs.
The main two technical challenges are (i) training those
MVNNs only on demand query observations and (ii) ef-
ficiently determining the next demand query that is most
likely to clear the market based on the trained MVNNs. In
detail, we make the following contributions:
1. We first propose an adjusted MVNN architecture, which
we call multiset MVNNs (mMVNNs). mMVNNs can be
used more generally in multiset domains (i.e., if mul-
tiple indistinguishable copies of the same good exist)
(Section 3.1) and we prove the universality property of
mMVNNs in such multiset domains (Theorem 1).
2. We introduce a novel method for training any MIP-
formalizable and gradient descent (GD)-compatible ML
model (e.g., mMVNNs) on demand query observations
(Section 3.2).1Unlike prior work, our training method
provably makes use of the complete information provided
by the demand query observations.
3. We introduce an efficient method for determining the
price vector that is most likely to clear the market based
on the trained ML models (Section 4). For this, we de-
rive a simple and intuitive price update rule that results
from performing GD on an objective function which is
minimized exactly at clearing prices (Theorem 3).
4. Based on Items 2and 3, we propose a practical ML-
powered clock auction (Section 5).
5. We experimentally show that compared to the CCA,
our ML-powered clock auction can achieve substantially
higher efficiency on the order of 9% points. Furthermore,
using linear prices, our ML-powered clock auction ex-
hibits significantly higher clearing potential compared to
the CCA (Section 6).
GitHub Our source code is publicly available on GitHub
at https://github.com/marketdesignresearch/ML-CCA.
1.3 Further Related Work
In the field of automated mechanism design,D¨
utting et al.
(2015,2019), Golowich, Narasimhan, and Parkes (2018)
and Narasimhan, Agarwal, and Parkes (2016) used ML to
learn new mechanisms from data, while Cole and Rough-
garden (2014); Morgenstern and Roughgarden (2015) and
Balcan, Sandholm, and Vitercik (2023) bounded the sample
complexity of learning approximately optimal mechanisms.
In contrast to this prior work, our design incorporates an ML
algorithm into the mechanism itself, i.e., the ML algorithm
is part of the mechanism. Lahaie and Lubin (2019) suggest
an adaptive price update rule that increases price expressiv-
ity as the rounds progress in order to improve efficiency and
speed of convergence. Unlike that work, we aim to improve
preference elicitation while still using linear prices. Prefer-
ence elicitation is a key market design challenge outside of
1Namely, this includes neural networks with any piecewise lin-
ear activation function.
2

CAs too. Soumalias et al. (2023) introduce an ML-powered
mechanism for course allocation that improves preference
elicitation by asking students comparison queries.
1.4 Practical Considerations and Incentives
Our ML-powered clock phase can be viewed as an alterna-
tive to the clock phase of the CCA. In a real-world appli-
cation, many other considerations (beyond the price update
rule) are also important. For example, the careful design of
activity rules is vital to induce truthful bidding in the clock
phase of the CCA (Ausubel and Baranov 2017). The pay-
ment rule used in the supplementary round is also important,
and it has been argued that the use of the VCG-nearest pay-
ment rule, while not strategy-proof, induces good incentives
in practice (Cramton 2013). Similar to the clock phase of the
CCA, our ML-powered clock phase is not strategyproof. If
our design were to be fielded in a real-world environment,
we envision that one would combine it with carefully de-
signed activity and payment rules in order to induce good
incentives. Thus, we consider the incentive problem orthog-
onal to the price update problem and in the rest of the pa-
per, we follow prior work (Brero, Lahaie, and Seuken 2019;
Parkes and Ungar 2000) and assume that bidders follow my-
opic best-response (truthful) bidding throughout all auction
mechanisms tested.
2 Preliminaries
2.1 Formal Model for ICAs
We consider multiset CA domains with a set N=
{1, . . . , n}of bidders and a set M={1, . . . , m}of distinct
items with corresponding capacities, i.e., number of avail-
able copies, c= (c1, . . . , cm)∈Nm. We denote by x∈
X={0, . . . , c1}×. . .×{0, . . . , cm}a bundle of items repre-
sented as a positive integer vector, where xj=kiff item j∈
Mis contained k-times in x. The bidders’ true preferences
over bundles are represented by their (private) value func-
tions vi:X → R≥0, i ∈N, i.e., vi(x)represents bidder i’s
true value for bundle x∈ X . We collect the value functions
viin the vector v= (vi)i∈N. By a= (a1, . . . , an)∈ X n
we denote an allocation of bundles to bidders, where aiis
the bundle bidder iobtains. We denote the set of feasible
allocations by F=a∈ X n:Pi∈Naij ≤cj,∀j∈M.
We assume that bidders have quasilinear utility functions ui
of the form ui(ai) = vi(ai)−πiwhere vican be highly non-
linear and πi∈R≥0denotes the bidder’s payment. This im-
plies that the (true) social welfare V(a)of an allocation ais
equal to the sum of all bidders’ values Pi∈Nvi(ai). We let
a∗∈argmaxa∈F V(a)denote a social-welfare maximiz-
ing, i.e., efficient, allocation. The efficiency of any allocation
a∈ F is determined as V(a)/V (a∗).
An ICA mechanism defines how the bidders interact with
the auctioneer and how the allocation and payments are de-
termined. In this paper, we consider ICAs that iteratively ask
bidders linear demand queries. In such a query, the auction-
eer presents a vector of item prices p∈Rm
≥0and each bidder
iresponds with her utility-maximizing bundle, i.e.,
x∗
i(p)∈argmax
x∈X
{vi(x)− ⟨p, x⟩} i∈N, (1)
where ⟨·,·⟩ denotes the Euclidean scalar product in Rm.
Even though our approach could conceptually incorpo-
rate any kind of (non-linear) price function p:X → R≥0,
our concrete implementation will only use linear prices (i.e.,
prices over items). Linear prices are most established in
practice since they are intuitive and simple for the bidders to
understand (e.g., (Ausubel, Cramton, and Milgrom 2006)).
For bidder i∈N, we denote a set of K∈Nsuch
elicited utility-maximizing bundles and price pairs as Ri=
{(x∗
i(pr), pr)}K
r=1. Let R= (R1, . . . , Rn)be the tuple of
elicited demand query data from all bidders. The ICA’s (in-
ferred) optimal feasible allocation a∗(R)∈ F and payments
πi:=πi(R)∈Rn
+are computed based on the elicited re-
ports Ronly. Concretely, a∗
R∈ F is defined as
a∗(R)∈argmax
F ∋ (x∗
i(pri))n
i=1
:ri∈{1,...,K} ∀i∈NX
i∈N
⟨pri, x∗
i(pri)⟩.(2)
In words, a bidder’s response to a demand query provides a
lower bound on that bidder’s value for the bundle she re-
quested. That lower bound is equal to the bundle’s price
in the round the bundle was requested. The ICA’s optimal
(inferred) feasible allocation a∗(R)∈ F is the one that
maximizes the corresponding lower bound on social wel-
fare, based on all elicited demand query data Rfrom the
bidders. As payment rule πi(R)one could use any reason-
able choice (e.g., VCG payments, see Appendix A). As the
auctioneer can only ask a limited number of demand queries
|Ri| ≤ Qmax (e.g., Qmax = 100), an ICA needs a practically
feasible and smart preference elicitation algorithm.
2.2 The Combinatorial Clock Auction (CCA)
We consider the CCA (Ausubel, Cramton, and Milgrom
2006) as the main benchmark auction. The CCA consists
of two phases. The initial clock phase proceeds in rounds. In
each round, the auctioneer presents anonymous item prices
p∈Rm
≥0, and each bidder is asked to respond to a demand
query, declaring her utility-maximizing bundle at p. The
clock phase of the CCA is parametrized by the reserve prices
employed in its first round, and the way prices are updated.
An item jis over-demanded at prices p, if, for those prices,
its total demand based on the bidders’ responses to the de-
mand query exceeds its capacity, i.e., Pi∈N(x∗
i(p))j> cj.
The most common price update rule is to increase the price
of all over-demanded items by a fixed percentage, which we
set to 5% for our experiments, as in many real-world appli-
cations (e.g., (Industry Canada 2013)).
The second phase of the CCA is the supplementary round.
In this phase, each bidder can submit a finite number of addi-
tional bids for bundles of items, which are called push bids.
Then, the final allocation is determined based on the com-
bined set of all inferred bids of the clock phase, plus all sub-
mitted push bids of the supplementary round. This design
aims to combine good price discovery in the clock phase
with good expressiveness in the supplementary round. In
simulations, the supplementary round is parametrized by the
assumed bidder behaviour in this phase, i.e., which bundle-
value pairs they choose to report. As in (Brero, Lubin, and
3

Algorithm 1: TRAINONDQ S
Input : Demand query data Ri={(x∗
i(pr), pr)}K
r=1,
Epochs T∈N, Learning Rate γ > 0.
1θ0←init mMVNN ▷Weissteiner et al. (2023, S.3.2)
2for t= 0 to T−1do
3for r= 1 to Kdo ▷Demand responses for prices
4Solve ˆx∗
i(pr)∈argmaxx∈X Mθt
i(x)− ⟨pr, x⟩
5if ˆx∗
i(pr)=x∗
i(pr)then ▷mMVNN is wrong
6L(θt)←(Mθt
i(ˆx∗
i(pr)) − ⟨pr,ˆx∗
i(pr)⟩)−
(Mθt
i(x∗
i(pr)) − ⟨pr, x∗
i(pr)⟩)▷Add
predicted utility difference to loss
7θt+1 ←θt−γ(∇θL(θ))θ=θt▷SGD step
8return Trained parameters θTof the mMVNN MθT
i
Seuken 2021), we consider the following heuristics when
simulating bidder behaviour:
•Clock Bids: Corresponds to having no supplementary
round. Thus, the final allocation is determined based only
on the inferred bids of the clock phase (Equation (2)).
•Raised Clock Bids: The bidders also provide their true
value for all bundles they bid on during the clock phase.
•Profit Max: Bidders provide their true value for all bun-
dles that they bid on in the clock phase, and additionally
submit their true value for the QP-Max bundles earning them
the highest utility at the prices of the final clock phase.
3 Training on Demand Query Observations
In this section, we first propose a new version of MVNNs
that are applicable to multiset domains Xand extend the
universality proof of classical MVNNs. Finally, we present
our demand-query training algorithm.
3.1 Multiset MVNNs
MVNNs (Weissteiner et al. 2022a) are a recently introduced
class of NNs specifically designed to represent monotone
combinatorial valuations. We introduce an adapted version
of MVNNs, which we call multiset MVNNs (mMVNNs).
Compared to MVNNs, mMVNNs have an added linear nor-
malization layer Dafter the input layer. We add this nor-
malization since the input (i.e., a bundle) x∈ X is a positive
integer vector instead of a binary vector as in the classic case
of indivisible items with capacities cj= 1 for all j∈M.
This normalization ensures that Dx ∈[0,1] and thus we can
use the weight initialization scheme from (Weissteiner et al.
2023). Unlike MVNNs, mMVNNs incorporate at a struc-
tural level the prior information that some items are identi-
cal and consequently significantly reduce the dimensional-
ity of the input space. This improves the sample efficiency
of mMVNNs, which is especially important in applications
with a limited number of samples such as auctions. For more
details on mMVNNs and their advantages, please see Ap-
pendix B.
Definition 1 (Multiset MVNN).An mMVNN Mθ
i:X →
R≥0for bidder i∈Nis defined as
Mθ
i(x):=Wi,Kiφ0,ti,Ki−1. . . φ0,ti,1(Wi,1(Dx) + bi,1). . .
(3)
•Ki+ 2 ∈Nis the number of layers (Kihidden layers),
•{φ0,ti,k }Ki−1
k=1 are the MVNN-specific activation functions
with cutoff ti,k >0, called bounded ReLU (bReLU):
φ0,ti,k (·):= min(ti,k,max(0,·)) (4)
•Wi:= (Wi,k)Ki
k=1 with Wi,k ≥0and bi:= (bi,k)Ki−1
k=1
with bi,k ≤0are the non-negative weights and non-
positive biases of dimensions di,k ×di,k−1and di,k, whose
parameters are stored in θ= (Wi, bi).
•D:= diag (1
/c1,...,1
/cm)is the linear normalization
layer that ensures Dx ∈[0,1] and is not trainable.
In Theorem 1, we extend the proof from Weissteiner et al.
(2022a) and show that mMVNNs are also universal in the
set of monotone value functions defined on a multiset do-
main X. For this, we first define the following properties:
(M) Monotonicity (“more items weakly increase value”):
For a, b ∈ X : if a≤b, i.e. ∀k∈M:ai≤bi, it holds
that vi(a)≤vi(b),
(N) Normalization (”no value for empty bundle”):
vi(∅) = vi((0,...,0)) := 0,
These properties are common assumptions and are satisfied
in many market domains. We can now present the following
universality result:
Theorem 1 (Multiset Universality).Any value function
vi:X → R+that satisfies (M) and (N) can be repre-
sented exactly as an mMVNN Mθ
ifrom Definition 1, i.e.,
for V:= {vi:X → R+|satisfy (M) and (N)}it holds that
V=nM(Wi,bi)
i:Wi≥0, bi≤0}o.(5)
Proof. Please, see Appendix B.2 for the proof.
Furthermore, we can formulate maximization over
mMVNNs, i.e., maxx∈X Mθ
i(x)− ⟨p, x⟩, as a mixed inte-
ger linear program (MILP) analogously to Weissteiner et al.
(2022a), which will be key for our ML-powered clock phase.
3.2 Training Algorithm
In Algorithm 1, we describe how we train, for each bid-
der i∈N, a distinct mMVNN Mθ
ion demand query data
Ri. Our design choices regarding this training algorithm
are motivated by the information that responses to demand
queries provide. According to myopic best response bidding,
at each round r, bidder ireports a utility-maximizing bundle
x∗
i(pr)∈ X at current prices pr. Formally, for all x∈ X :
vi(x∗
i(pr)) − ⟨pr, x∗
i(pr)⟩ ≥ vi(x)− ⟨pr, x⟩.(6)
Notice that for any epoch tand round r, the loss L(θt)for
that round calculated in Lines 4to 6is always non-negative,
and can only be zero if the mMVNN Mθ
i(instead of vi)
satisfies Equation (6). Thus, the loss for an epoch is zero
iff the mMVNN Mθ
isatisfies Equation (6) for all rounds,
and in that case the model has captured the full information
provided by the demand query responses Riof that bidder.
Finally, note that Algorithm 1can be applied to any MILP-
formalizable ML model whose parameters can be efficiently
updated via GD, such as MVNNs or ReLU-NNs.
4

Figure 1: Scaled prediction vs. true plot of a trained
mMVNN via Algorithm 1for the national bidder in the
MRVM domain (see Section 6).
In Figure 1, we present a prediction vs. true plot of an
mMVNN, which we trained via Algorithm 1. We present
the training set of 50 demand query data points Riin blue
circles, where the prices {pr}50
r=1 are generated according
to the same rule as in CCA. Additionally, we mark the bun-
dle xCCA ∈ X from this last CCA iteration (i.e., the one
resulting from p50) with a black star. Moreover, we present
two different validation sets on which we evaluate mMVNN
configurations in our hyperparameter optimization (HPO):
Validation set 1 (red circles), which are 50,000 uniformly at
random sampled bundles x∈ X , and validation set 2 (green
circles), where we first sample 500 price vectors {pr}500
r=1
where the price of each item is drawn uniformly at random
from the range of 0to 3times the average maximum value
of an agent of that type for a single item, and then deter-
mine utility-maximizing bundles x∗
i(pr)(w.r.t. vi) at those
prices (cp. Equation (1)). While validation set 1 measures
generalization performance in a classic sense over the whole
bundle space, validation set 2 focuses on utility-maximizing
bundles. We additionally demonstrate the inferred values
of the bundles of the training set and validation set 2 us-
ing triangles of the same colour, i.e., {⟨pr, x∗
i(pr)⟩}50/500
r=1 .
These triangles highlight the only cardinal information that
our mMVNNs have access to during training and are a
lower bound of the true value. In Figure 1, we see that our
mMVNN is able to learn at the training points (blue cir-
cles) the true value functions almost perfectly up to a con-
stant shift κ, i.e., MθT
i(x)≈vi(x) + κ. This is true even
though the corresponding inferred values (blue triangles) are
very far off from the true values ⟨pr, x∗
i(pr)⟩ ≪ vi(x∗
i(pr)).
Moreover, the mMVNN generalizes well (up to the constant
shift κ) on validation sets 1 and 2. Overall, this shows that
Algorithm 1indeed leads to mMVNNs MθT
iwhich are a
good approximation of vi+κ. Note that learning the true
value function up to a constant shift suffices for our proposed
demand query generation procedure presented in Section 4.
4 ML-powered Demand Query Generation
In this section, we show how we generate ML-powered de-
mand queries and provide the theoretical foundation for our
approach by extending a well-known connection between
clearing prices,efficiency and a clearing objective function.
First, we define indirect utility, revenue and clearing prices.
Definition 2 (Indirect Utility and Revenue).For linear
prices p∈Rm
≥0, a bidder’s indirect utility Uand the seller’s
indirect revenue Rare defined as
U(p, vi):= max
x∈X {vi(x)− ⟨p, x⟩} and (7)
R(p):= max
a∈F (X
i∈N
⟨p, ai⟩)1
=X
j∈M
cjpj,(8)
i.e., at prices p, Equations (7)and (8)are the maximum util-
ity a bidder can achieve for all x∈ X and the maximum rev-
enue the seller can achieve among all feasible allocations.
Definition 3 (Clearing Prices).Prices p∈Rm
≥0are clearing
prices if there exists an allocation a(p)∈ F such that
1. for each bidder i, the bundle ai(p)maximizes her utility,
i.e., vi(ai(p)) − ⟨p, ai(p)⟩=U(p, vi),∀i∈N, and
2. the allocation a(p)∈ F maximizes the sellers revenue,
i.e., Pi∈N⟨p, ai(p)⟩=R(p).2
Next, we provide an important connection between clear-
ing prices,efficiency and a clearing objective W. Theorem 2
extends Bikhchandani and Ostroy (2002, Theorem 3.1).
Theorem 2. Consider the notation from Definitions 2
and 3and the objective function W(p, v):=R(p) +
Pi∈NU(p, vi). Then it holds that, if a linear clearing price
vector exists, every price vector
p′∈argmin
˜p∈Rm
≥0
W(˜p, v)(9a)
such that (x∗
i(˜p))i∈N∈ F (9b)
is a clearing price vector and the corresponding allocation
a(p′)∈ F is efficient.3
Proof. Please, see Appendix C.1 for the proof.
Theorem 2does not claim the existence of linear clearing
prices (LCPs) p∈Rm
≥0. For general value functions v, LCPs
may not exist (Bikhchandani and Ostroy 2002). However, in
the case that LCPs do exist, Theorem 2shows that all min-
imizers of (9) are LCPs and their corresponding allocation
is efficient. This is at the core of our ML-powered demand
query generation approach, which we discuss next.
The key idea to generate ML-powered demand queries is
as follows: As an approximation for the true value function
2For linear prices, this maximum is achieved by selling every
item, i.e., ∀j∈M:Pi∈N(ai)j=cj(see Appendix C.2).
3More precisely, constraint (9b) should be reformulated as
∃(x∗
i(˜p))i∈N∈×
i∈N
X∗
i(˜p) : (x∗
i(˜p))i∈N∈ F ,
where X∗
i(˜p) := argmaxx∈X {vi(x)− ⟨ ˜p, x⟩}, since in theory,
x∗
i(˜p)does not always have to be unique.
5

vi, we use for each bidder a distinct mMVNN Mθ
i:X →
R≥0that has been trained on the bidder’s elicited demand
query data Ri(see Section 3). Motivated by Theorem 2, we
then try to find the demand query p∈Rm
≥0minimizing
W(p, Mθ
in
i=1)subject to the feasibility constraint (9b).
This way, we find demand queries p∈Rm
≥0which, given
the already observed demand responses R, have high clear-
ing potential. Note that unlike the CCA, this process does
not result in monotone prices.4
Remark 1 (Constraint (9b)).An important economic insight
is that minimizing W(·,(Mθ
i)n
i=1)is optimal, when LCPs
exist (also without constraint (9b)as shown in Lemma 2in
Appendix C.1). If however LCPs do not exist, it is favourable
to minimize Wunder the constraint of having no predicted
over-demand for any items (see Appendix D.9 for an em-
pirical comparison of minimizing Wwith and without con-
straint (9b)). This is because in case the market does not
clear, our ML-CCA (see Section 5), just like the CCA, will
have to combine the clock bids of the agents to produce a
feasible allocation with the highest inferred social welfare
according to Equation (2). See Appendix D.6 for details.
Note that (9) is a hard, bi-level optimization problem. We
minimize (9) via gradient descent (GD), since Theorem 3
gives us the gradient and convexity of W(·,Mθ
in
i=1).
Theorem 3. Let Mθ
in
i=1 be a tuple of trained mMVNNs
and let ˆx∗
i(p)∈argmaxx∈X Mθ
i(x)− ⟨p, x⟩denote
each bidder’s predicted utility maximizing bundle w.r.t.
Mθ
i. Then it holds that p7→ W(p, Mθ
in
i=1)is convex,
Lipschitz-continuous and a.e. differentiable. Moreover,
c−X
i∈N
ˆx∗
i(p)∈ ∇sub
pW(p, Mθ
in
i=1)(10)
is always a sub-gradient and a.e. a classical gradient.
Proof. In Appendix C.2 we provide the full proof. Con-
cretely, Lemmas 3and 4prove the Lipschitz-continuity and
the convexity. In the following, we provide a sketch of how
the (sub-)gradients are derived. First, since Xis finite, it
is intuitive that ˆx∗
i(p)is a piece-wise constant function and
thus ∂pˆx∗
i(p)a.e.
= 0 (as intuitively argued by Poganˇ
ci´
c et al.
(2020) and proven by us in Lemma 6). Then we can compute
4We see no reason why non-monotone prices would introduce
additional complexity for the bidders. With our approach, the prices
quickly converge to the final prices, and then only change very lit-
tle, as shown in Figures 5to 8of Appendix D.7. For this reason,
one could even argue that round-over-round optimizations for the
bidders may be easier in our auction: given that prices are close
to each other round-over-round, the optimal bundle from the last
round is still close to optimal (in terms of utility) in the next round.
the gradient a.e. as if ˆx∗
i(p)was a constant:
∇pWp, Mθ
in
i=1=∇p R(p) + X
i∈N
U(p, Mθ
i)!
=∇p
X
j∈M
cjpj+X
i∈NMθ
i(ˆx∗
i(p)) − ⟨p, ˆx∗
i(p)⟩

a.e.
=c+X
i∈N
(0 − ∇p⟨p, ˆx∗
i(p)⟩) = c−X
i∈N
ˆx∗
i(p).
For a mathematically rigorous derivation of sub-gradients
and a.e. differentiability see Lemmas 5and 6.
With Theorem 3, we obtain the following update rule of
classical GD pnew
j
a.e.
=pj−γ(cj−Pi∈N(ˆx∗
i(p))j),∀j∈M.
Interestingly, this equation has an intuitive economic inter-
pretation. If the jth item is over/under-demanded based on
the predicted utility-maximizing bundles ˆx∗
i(p), then its new
price pnew
jis increased/decreased by the learning rate times
its over/under-demand. However, to enforce constraint (9b)
in GD, we asymmetrically increase the prices 1 + µ∈R≥0
times more in case of over-demand than we decrease them
in case of under-demand. This leads to our final update rule
(see Item 1in Appendix D.6 for more details):
pnew
j
a.e.
=pj−˜γj(cj−X
i∈N
(ˆx∗
i(p))j),∀j∈M, (11a)
˜γj:=γ·(1 + µ), cj<Pi∈N(ˆx∗
i(p))j
γ , else (11b)
To turn this soft constraint into a hard constraint, we in-
crease this asymmetry via µiteratively until we achieve fea-
sibility and in the end we select the GD step with the lowest
Wvalue within those steps that were feasible. Based on the
final update rule from (11), we propose NEXT PRIC E (Algo-
rithm 3in Appendix D.6), an algorithm that generates de-
mand queries with high clearing potential, which addition-
ally induce utility-maximizing bundles that are predicted to
be feasible (see Appendix D.6 for all details).
5 ML-powered Combinatorial Clock Auction
In this section, we describe our ML-powered combinatorial
clock auction (ML-CCA), which is based on our proposed
new training algorithm from Section 3as well as our new
demand query generation procedure from Section 4.
We present ML-CCA in Algorithm 2. In Lines 2to 5,
we draw the first Qinit price vectors using some initial de-
mand query method Finit and receive the bidders’ demand
responses to those price vectors. Concretely, in Section 6,
we report results using the same price update rule as the
CCA for Finit. In each of the next up to Qmax −Qinit ML-
powered rounds, we first train, for each bidder, an mMVNN
on her demand responses using Algorithm 1(Line 8). Next,
in Line 9, we call NEXT PRICE to generate the next demand
query pbased on the agents’ trained mMVNNs (see Sec-
tion 4). If, based on the agents’ responses to the demand
query (Line 11), our algorithm has found market-clearing
6

GSVM LSVM SRVM MRVM
MECHANISM ECLOCK ERAI SE EPROFI T CLEA R ECLOCK ERAISE EP ROFIT CL EAR ECLOCK ERAISED EPR OFIT CLE AR ECLOCK ERAI SE EPROFI T CLEA R
ML-CCA 98.23 98.93 100.00 56 91.64 96.39 99.95 26 99.59 99.93 100.00 13 93.04 93.31 93.68 0
CCA 90.40 93.59 100.00 3 82.56 91.60 99.76 0 99.63 99.81 100.00 8 92.44 92.62 93.18 0
Table 1: ML-CCA vs CCA. Shown are averages over a test set of 100 synthetic CA instances of the following metrics: efficiency
in % for clock bids (ECLOCK), raised clock bids (ERAIS E ) and raised clock bids plus 100 profit-max bids (EP ROFI T ) and percentage
of instances where clearing prices were found (CLE AR). Winners based on a paired t-test with α= 5% are marked in grey.
Algorithm 2: ML-CCA(Qinit, Qmax, Finit )
Parameters: Qinit, Qmax with Qinit ≤Qmax and Finit
1R←({})N
i=1
2for r= 1, ..., Qinit do ▷Draw Qinit initial prices
3pr←Finit(R)
4foreach i∈Ndo ▷Initial demand query responses
5Ri←Ri∪ {(x∗
i(pr), pr)}
6for r=Qinit + 1, ..., Qmax do ▷ML-powered rounds
7foreach i∈Ndo
8Mθ
i←TRA INONDQS(Ri)▷Algorithm 1
9pr←NEX TPRI CE(Mθ
in
i=1)▷Algorithm 3
10 foreach i∈Ndo ▷Demand query responses for pr
11 Ri←Ri∪ {(x∗
i(pr), pr)}
12 if
n
P
i=1
(x∗
i(pk))j=cj∀j∈Mthen ▷Market-clearing
13 Set final allocation a∗(R)←(x∗
i(pr))n
i=1
14 Calculate payments π(R)←(πi(R))n
i=1
15 return a∗(R)and π(R)
16 foreach i∈Ndo
17 Ri←Ri∪Bi▷Optional Push bids
18 Calculate final allocation a∗(R)as in Equation (2)
19 Calculate payments π(R)▷E.g., VCG (Appendix A)
20 return a∗(R)and π(R)
prices, then the corresponding allocation is efficient and is
returned, along with payments π(R)according to the de-
ployed payment rule (Line 15). If, by the end of the ML-
powered rounds, the market has not cleared, we optionally
allow bidders to submit push bids, analogously to the sup-
plementary round of the CCA (Line 17) and calculate the
optimal allocation a∗(R)and the payments π(R)(Lines 18
and 19). Note that ML-CCA can be combined with various
possible payment rules π(R), such as VCG or VCG-nearest.
6 Experiments
In this section, we experimentally evaluate the performance
of our proposed ML-CCA from Algorithm 2.
6.1 Experiment Setup.
To generate synthetic CA instances, we use the GSVM,
LSVM, SRVM, and MRVM domains from the spectrum
auction test suite (SATS) (Weiss, Lubin, and Seuken 2017)
(see Appendix D.1 for details). We compare our ML-CCA
with the original CCA. For both mechanisms, we allow a
maximum of 100 clock rounds per instance, i.e., we set
Qmax = 100. For CCA, we set the price increment to 5% as
in (Industry Canada 2013) and optimized the initial reserve
prices to maximize its efficiency. For ML-CCA, we create
Qinit price vectors to generate the initial demand query data
using the same price update rule as the CCA, with the price
increment adjusted to accommodate for the reduced num-
ber of rounds following this price update rule. In GSVM,
LSVM and SRVM we set Qinit = 20 for ML-CCA, while in
MRVM we set Qinit = 50. After each clock round, we report
efficiency according to the clock bids up to that round, as
well as efficiency if those clock bids were raised (see Sec-
tion 2.2). Finally, we report the efficiency if the last clock
round was supplemented with QP-Max = 100 bids using the
profit max heuristic. Note that this is a very unrealistic and
cognitively expensive bidding heuristic in practice, as it re-
quires the agents to both discover their top 100 most prof-
itable bundles as well as report their exact values for them,
and thus only adds theoretical value to gauge the difficulty
of each domain.
6.2 Hyperparameter Optimization (HPO).
We optimized the hyperparameters (HPs) of the mMVNNs
for each bidder type of each domain. Specifically, for each
bidder type we trained an mMVNN on the demand re-
sponses of a bidder of that type on 50 CCA clock rounds
and selected the HPs that resulted in the highest R2on val-
idation set 2as described in Section 3.1. For more details
please see Appendix D.3.
6.3 Results.
All efficiency results are presented in Table 1, while in Fig-
ure 2we present the efficiency after each clock round, as
well as the efficiency if those clock bids were enhanced with
the clock bids raised heuristic (for 95% CIs and p-values see
Appendix D.7).
In GSVM, ML-CCA’s clock phase exhibits over 7.8%
points higher efficiency compared to the CCA, while if we
add the clock bids raised heuristic to both mechanisms, ML-
CCA still exhibits over 5.3% points higher efficiency. At the
same time, ML-CCA is able to find clearing prices in 56%
of the instances, as opposed to only 3% for the CCA.
The results for LSVM are qualitatively very similar; ML-
CCA’s clock phase increases efficiency compared to the
CCA by over 9% points, while clearing the market in 26% of
the cases as opposed to 0%. If we add the clock bids raised
heuristic to both mechanisms, ML-CCA still increases effi-
ciency by over 4.7% points.
The SRVM domain, as suggested by the existence of only
3unique goods, is quite easy to solve. Thus, both mecha-
nisms can achieve almost 100% efficiency after their clock
7

60
70
80
90
100
Efficiency in %
GSVM
ML-CCA clock bids
ML-CCA raised clock bids
CCA clock bids
CCA raised clock bids
80
90
100 LSVM
2 20 40 60 80 100
Clock Round
60
80
100
Efficiency in %
SRVM
2 20 40 60 80 100
Clock Round
60
80
100 MRVM
Figure 2: Efficiency path plots in SATS for ML-CCA and
CCA both after clock bids (solid lines) and raised clock bids
(dashed lines). Averaged over 100 runs including a 95% CI.
The dashed black vertical line indicates the value of Qinit.
phase. For the clock bids raised heuristic our method reduces
the efficiency loss by a factor of more than two (from 0.19%
to 0.07%), and additionally, one can see from Figure 2that
our method reaches over 99% in less than 30 rounds.
In MRVM, ML-CCA again achieves statistically signif-
icantly better results for all 3 bidding heuristics. Notably,
the CCA needs both the clock bids raised heuristic and 38
profit max bids to reach the same efficiency as our ML-CCA
clock phase, i.e., it needs up to 138 additional value queries
per bidder (see Appendix D.7). In MRVM, LCPs never ex-
ist, thus neither ML-CCA nor the CCA can ever clear the
market.
To put our efficiency improvements in perspective, in
the GSVM, LSVM and MRVM domains, ML-CCA’s clock
phase achieves higher efficiency than the CCA enhanced
with the clock bids raised heuristic, i.e., the CCA, even if it
uses up to an additional 100 value queries per bidder, cannot
match the efficiency of our ML-powered clock phase. In Fig-
ure 2, we see that our ML-CCA can (almost) reach the effi-
ciency numbers of Table 1in a significantly reduced number
of clock rounds compared to the CCA, while if we attempt
to “speed up” the CCA, then its efficiency can substantially
drop, see Appendix D.8. In particular, in GSVM and LSVM,
using 50 clock rounds, our ML-CCA can achieve higher ef-
ficiency than the CCA can in 100 clock rounds.
6.4 Computational Efficiency.
For our choice of hyperparameters, the computation time
when using 8CPU cores5(see Appendix D.2 for details on
our compute infrastructure) for a single round of the ML-
CCA averages under 45 minutes for all domains tested. No-
tably, for three out of four domains, it averages less than 10
minutes (see Table 7in Appendix D.7). The overwhelming
majority of this time is devoted to training the mMVNNs of
5Note that Algorithm 1is not GPU-implementable, as it re-
quires solving a MIP in each iteration, for every demand response
by an agent
all bidders using our Algorithm 1and generating the next
DQ using our Algorithm 3detailed in Section 4. It is im-
portant to note that both of these algorithms can always be
parallelized by up to the number of bidders N, further re-
ducing the time required. In our implementation, while we
parallelized the training of the NmMVNNs, we did not do
so for the generation of the next DQ. In spectrum auctions,
typically no more than 2rounds are conducted per day. For
the results presented in this paper, we ran the full auction for
400 instances. Given the estimated welfare improvements of
over 25 million USD per auction, attributed to ML-CCA’s
efficiency gains, we consider ML-CCA’s computational and
time requirements to be negligible.
7 Conclusion
We have proposed a novel method for training MVNNs to
approximate the bidders’ value functions based on demand
query observations. Additionally, we have framed the task of
determining the price vector with the highest clearing poten-
tial as minimization of an objective function that we prove is
convex, Lipschitz-continuous, a.e. differentiable, and whose
gradient for linear prices has an intuitive economic interpre-
tation: change the price of every good proportionally to its
predicted under/over-demand at the current prices. The re-
sulting mechanism (ML-CCA) from combining these two
components exhibits significantly higher clearing potential
than the CCA and can increase efficiency by up to 9% points
while at the same time converging in a much smaller number
of rounds. Thus, we have designed the first practical ML-
powered auction that employs the same interaction paradigm
as the CCA, i.e., demand queries instead of cognitively too
complex value queries, yet is able to significantly outper-
form the CCA in terms of both efficiency and clearing po-
tential in realistic domains.
Acknowledgments
This paper is part of a project that has received funding
from the European Research Council (ERC) under the Eu-
ropean Union’s Horizon 2020 research and innovation pro-
gram (Grant agreement No. 805542).
References
Ausubel, L. M.; and Baranov, O. 2017. A practical guide
to the combinatorial clock auction. Economic Journal,
127(605): F334–F350. 1,3,11,12,24
Ausubel, L. M.; and Baranov, O. 2019. Iterative Vickrey
Pricing in Dynamic Auctions. 12
Ausubel, L. M.; and Baranov, O. 2020. Revealed Preference
and Activity Rules in Dynamic Auctions. International Eco-
nomic Review, 61(2): 471–502. 12
Ausubel, L. M.; and Baranov, O. V. 2014. Market Design
and the Evolution of the Combinatorial Clock Auction. The
American Economic Review, 104(5): 446–451. 12
Ausubel, L. M.; Cramton, P.; and Milgrom, P. 2006. The
clock-proxy auction: A practical combinatorial auction de-
sign. In Cramton, P.; Shoham, Y.; and Steinberg, R., eds.,
Combinatorial Auctions, 115–138. MIT Press. 1,3
8

Balcan, M.-F.; Sandholm, T.; and Vitercik, E. 2023. Gen-
eralization Guarantees for Multi-item Profit Maximiza-
tion: Pricing, Auctions, and Randomized Mechanisms.
arXiv:1705.00243. 2
Bertsekas, D. P. 1971. Control of uncertain systems with a
set-membership description of the uncertainty. Ph.D. thesis,
Massachusetts Institute of Technology. 17
Bertsekas, D. P. 1999. Nonlinear Programming. Athena
scientific optimization and computation series. Athena Sci-
entific. ISBN 9781886529007. 17
Bichler, M.; Hao, Z.; and Adomavicius, G. 2017. Coalition-
based pricing in ascending combinatorial auctions, 493–
528. Cambridge University Press. ISBN 9781107135345.
1
Bikhchandani, S.; and Ostroy, J. M. 2002. The package as-
signment model. Journal of Economic theory, 107(2): 377–
406. 5,14
Blum, A.; Jackson, J.; Sandholm, T.; and Zinkevich, M.
2004. Preference elicitation and query learning. Journal
of Machine Learning Research, 5: 649–667. 1
Brero, G.; and Lahaie, S. 2018. A Bayesian clearing mecha-
nism for combinatorial auctions. In Proceedings of the 32nd
AAAI Conference on Artificial Intelligence.2
Brero, G.; Lahaie, S.; and Seuken, S. 2019. Fast Iterative
Combinatorial Auctions via Bayesian Learning. In Proceed-
ings of the 33rd AAAI Conference of Artificial Intelligence.
2,3
Brero, G.; Lubin, B.; and Seuken, S. 2018. Combinatorial
Auctions via Machine Learning-based Preference Elicita-
tion. In Proceedings of the 27th International Joint Con-
ference on Artificial Intelligence.1
Brero, G.; Lubin, B.; and Seuken, S. 2021. Machine
Learning-powered Iterative Combinatorial Auctions. arXiv
preprint arXiv:1911.08042.1,3
Cole, R.; and Roughgarden, T. 2014. The Sample Com-
plexity of Revenue Maximization. In Proceedings of the
Forty-Sixth Annual ACM Symposium on Theory of Comput-
ing, STOC ’14, 243–252. New York, NY, USA: Association
for Computing Machinery. ISBN 9781450327107. 2
Cramton, P. 2013. Spectrum auction design. Review of In-
dustrial Organization, 42(2): 161–190. 1,2,3
Danskin, J. M. 1967. The theory of Max-Min and its applica-
tion to weapons allocation problems [by] John M. Danskin.
Springer-Verlag Berlin, New York. 17
D¨
utting, P.; Feng, Z.; Narasimhan, H.; Parkes, D. C.; and
Ravindranath, S. S. 2019. Optimal auctions through deep
learning. In Proceedings of the 36th International Confer-
ence on Machine Learning.2
D¨
utting, P.; Fischer, F.; Jirapinyo, P.; Lai, J. K.; Lubin, B.;
and Parkes, D. C. 2015. Payment rules through discriminant-
based classifiers. ACM Transactions on Economics and
Computation, 3(1): 5. 2
Goeree, J. K.; and Holt, C. A. 2010. Hierarchical package
bidding: A paper & pencil combinatorial auction. Games
and Economic Behavior, 70(1): 146–169. 19
Goetzendorff, A.; Bichler, M.; Shabalin, P.; and Day, R. W.
2015. Compact Bid Languages and Core Pricing in Large
Multi-item Auctions. Management Science, 61(7): 1684–
1703. 1
Golowich, N.; Narasimhan, H.; and Parkes, D. C. 2018.
Deep Learning for Multi-Facility Location Mechanism De-
sign. In Proceedings of the Twenty-seventh International
Joint Conference on Artificial Intelligence and the Twenty-
third European Conference on Artificial Intelligence, 261–
267. 2
Heiss, J. M.; Weissteiner, J.; Wutte, H. S.; Seuken, S.; and
Teichmann, J. 2022. NOMU: Neural Optimization-based
Model Uncertainty. In Proceedings of the 39th International
Conference on Machine Learning, volume 162 of Proceed-
ings of Machine Learning Research, 8708–8758. PMLR. 2
Industry Canada. 2013. ”Responses to Clarification Ques-
tions on the Licensing Framework for Mobile Broadband
Services (MBS) — 700 MHz Band”. 3,7
Kwasnica, A. M.; Ledyard, J. O.; Porter, D.; and DeMartini,
C. 2005. A New and Improved Design for Multiobject Iter-
ative Auctions. Management Science, 51(3): 419–434. 1
Lahaie, S.; and Lubin, B. 2019. Adaptive-Price Combi-
natorial Auctions. In Proceedings of the 2019 ACM Con-
ference on Economics and Computation, EC ’19, 749–750.
New York, NY, USA: Association for Computing Machin-
ery. ISBN 9781450367929. 2
Lahaie, S. M.; and Parkes, D. C. 2004. Applying learning
algorithms to preference elicitation. In Proceedings of the
5th ACM Conference on Electronic Commerce.1
Milgrom, P.; and Segal, I. 2017. Designing the US incentive
auction. Handbook of spectrum auction design, 803–812. 1
Morgenstern, J.; and Roughgarden, T. 2015. The Pseudo-
Dimension of near-Optimal Auctions. In Proceedings of the
28th International Conference on Neural Information Pro-
cessing Systems - Volume 1, NIPS’15, 136–144. Cambridge,
MA, USA: MIT Press. 2
Narasimhan, H.; Agarwal, S. B.; and Parkes, D. C. 2016.
Automated mechanism design without money via machine
learning. In Proceedings of the 25th International Joint Con-
ference on Artificial Intelligence.2
Nisan, N.; and Segal, I. 2006. The communication require-
ments of efficient allocations and supporting prices. Journal
of Economic Theory, 129(1): 192–224. 1
Parkes, D. C.; and Ungar, L. H. 2000. Iterative combinatorial
auctions: Theory and practice. In Proceedings of the seven-
teenth national Conference on artificial intelligence, 74–81.
3
Poganˇ
ci´
c, M. V.; Paulus, A.; Musil, V.; Martius, G.; and Ro-
linek, M. 2020. Differentiation of blackbox combinatorial
solvers. In International Conference on Learning Represen-
tations.6
Rassenti, S. J.; Smith, V. L.; and Bulfin, R. L. 1982. A com-
binatorial auction mechanism for airport time slot allocation.
The Bell Journal of Economics, 402–417. 1
Rockafellar, R. T. 1970. Convex Analysis. Princeton: Prince-
ton University Press. ISBN 9781400873173. 17,18
9

Scheffel, T.; Ziegler, G.; and Bichler, M. 2012. On the im-
pact of package selection in combinatorial auctions: an ex-
perimental study in the context of spectrum auction design.
Experimental Economics, 15(4): 667–692. 19
Soumalias, E.; Weissteiner, J.; Heiss, J.; and Seuken, S.
2024. Machine Learning-powered Combinatorial Clock
Auction. Proceedings of the AAAI Conference on Artificial
Intelligence, 38. 1
Soumalias, E.; Zamanlooy, B.; Weissteiner, J.; and Seuken,
S. 2023. Machine Learning-powered Course Allocation.
arXiv preprint arXiv:2210.00954.3
Weiss, M.; Lubin, B.; and Seuken, S. 2017. Sats: A univer-
sal spectrum auction test suite. In Proceedings of the 16th
Conference on Autonomous Agents and MultiAgent Systems,
51–59. 7,19
Weissteiner, J.; Heiss, J.; Siems, J.; and Seuken, S. 2022a.
Monotone-Value Neural Networks: Exploiting Preference
Monotonicity in Combinatorial Assignment. In Proceedings
of the Thirty-First International Joint Conference on Arti-
ficial Intelligence, IJCAI-22, 541–548. International Joint
Conferences on Artificial Intelligence Organization. Main
Track. 2,4,12,13,14,20,23
Weissteiner, J.; Heiss, J.; Siems, J.; and Seuken, S. 2023.
Bayesian Optimization-based Combinatorial Assignment.
Proceedings of the AAAI Conference on Artificial Intelli-
gence, 37. 2,4,11,12,14,20,23
Weissteiner, J.; and Seuken, S. 2020. Deep Learn-
ing—Powered Iterative Combinatorial Auctions. Proceed-
ings of the AAAI Conference on Artificial Intelligence,
34(02): 2284–2293. 1,12,20
Weissteiner, J.; Wendler, C.; Seuken, S.; Lubin, B.; and
P¨
uschel, M. 2022b. Fourier Analysis-based Iterative Com-
binatorial Auctions. In Proceedings of the Thirty-First Inter-
national Joint Conference on Artificial Intelligence, IJCAI-
22, 549–556. International Joint Conferences on Artificial
Intelligence Organization. Main Track. 1,12
10

Appendix
A Payment and Activity Rules
In this section, we reprint the VCG and VCG-nearest pay-
ment rules, as well as give an overview of activity rules for
the CCA, and argue why the most prominent choices are also
applicable to our ML-CCA.
A.1 VCG Payments from Demand Query Data
Definition A.1. (VCG PAYME NTS FROM DEMAND
QUE RY DATA)Let R= (R1, . . . , Rn)denote an elicited
set of demand query data from each bidder and let R−i:=
(R1, . . . , Ri−1, Ri+1, . . . , Rn). We then calculate the VCG
payments πVCG(R)=(πVCG
1(R)...,πVCG
n(R)) ∈Rn
≥0as fol-
lows:
πVCG
i(R):=(12)
X
j∈N\{i}Dp∗
R−ij,a∗
R−ijE−X
j∈N\{i}D(p∗
R)j,(a∗
R)jE.
(13)
where a∗
R−iis the allocation that maximizes the inferred so-
cial welfare (SW) when excluding bidder i, i.e.,
a∗
R−i∈argmax
F ∋ (x∗
j(p(rj)))j∈N\{i}
:rj∈{1,...,K} ∀j∈N\{i}X
j∈N\{i}Dp(rj), x∗
j(p(rj))E,
(14)
and p∗
R−i=(p∗
R−i)1,...,(p∗
R−i)n∈Rmn
≥0de-
note the corresponding price vectors that lead to a∗
R−i,
and a∗
Ris a inferred-social-welfare-maximizing alloca-
tion (see Equation (2)) with corresponding prices p∗
R=
((p∗
R)1,...,(p∗
R)n)∈Rmn
≥0.
Thus, when using VCG, bidder i’s utility is:
ui=vi((a∗
R)i)−πVCG
i(R)
=vi((a∗
R)i) + X
j∈N\{i}
D(p∗
R)j,(a∗
R)jE−X
j∈N\{i}
Dp∗
R−ij,a∗
R−ijE.
Remark A.1. Note that Definition A.1 defines VCG pay-
ments for a set of elicited demand query data Rusing the
bidders’ inferred values from this data set. Specifically, those
would be the VCG payments after the CCA’s clock phase for
example (i.e., if there was no supplementary round). How-
ever, one can analogously define VCG-payments for any
given set of reported bundle-value pairs (see Weissteiner
et al. (2023, Definition B.1.)). For example, in the case of ad-
ditional value bids, such as supplementary round push bids,
one would use Weissteiner et al. (2023, Definition B.1.) and
set ˆvi(xr) = max{⟨xr, pr⟩, bs
i(xr)}, where bsis the bid-
der’s supplementary round bid for that bundle (or zero, if
she did not bid on it in the supplementary round), i.e., bidder
i’s bid for any bundle is the maximum of her largest inferred
value for that bundle based on the clock round bids and the
supplementary round bids.
A.2 VCG-Nearest Payments
To define the VCG-nearest payments, we must first intro-
duce the core:
Definition A.2. (T HE CORE)An outcome (a, π )∈ F ×Rn
≥0
(i.e., a tuple of a feasible allocation aand payments π) is in
the core if it satisfies the following two properties:
1. The outcome is individual rational, i.e, ui=vi(ai)−
πi≥0for all i∈N
2. The core constraints
∀L⊆NX
i∈N\L
πi(R)≥max
a′∈F X
i∈L
vi(a′
i)−X
i∈L
vi(ai)
(15)
where vi(ai)is bidder i’s value for bundle aiand Fis
the set of feasible allocations.
In words, a payment vector π(together with a feasible
allocation a) is in the core if no coalition of bidders L⊂N
is willing to pay more for the items than the mechanism is
charging the winners. Note that by replacing the true values
vi(ai)with the bidders’ (possibly untruthful) bids bi(ai)in
Definition A.2 one can equivalently define the revealed core.
Now, we can define
Definition A.3. (MINIMUM REVE NUE CORE )Among all
payment vectors in the (revealed) core, the (revealed) mini-
mum revenue core is the set of payment vectors with smallest
L1-norm, i.e., which minimize the sum of the payments of all
bidders.
We can now define VCG-nearest payments:
Definition A.4. (VCG-NEA RES T PAYMENTS )Given an
allocation aRfor bidder reports R, the VCG-nearest pay-
ments πVCG-nearest(R)are defined as the vector of payments
in the (revealed) minimum revenue core that minimizes the
L2-norm to the VCG payment vector πVCG(R).
A.3 On the Importance of Activity Rules to Align
Incentives
In the CCA, activity rules serve multiple purposes. First,
they can help speed up the auction process. Second, they
reduce ”bid-sniping” opportunities, i.e., bidders concealing
their true intentions until the very last rounds of the auc-
tion.6Third, they can limit surprise bids in the supplemen-
tary round of the CCA and significantly reduce a bidder’s
ability to drive up her opponents payments by overbidding
on bundles that she can no longer win (Ausubel and Baranov
2017). There are two types of activity rules that are imple-
mented in a CCA:
1. Clock phase activity rules, that limit the bundles that an
agent can bid on during the clock phase, based on her
bids in previous clock rounds.
2. Supplementary round activity rules, that restrict the
amount that an agent can bid on for various sets of items
during the supplementary round.
6The notion of “bid-sniping” first originated in eBay auctions
with predetermined ending times, where the high-value bidder can
sometimes reduce her payments by submitting her bid at the very
last moment.
11

Most of the activity rules that were traditionally used for
the clock phase of the CCA were based on either revealed-
preference considerations or some points-based system,
where the main idea is to assign points to each item prior to
the auction, and only allow bidders to submit monotonically
non-increasing in points bids, i.e., as the rounds progress and
the prices increase, the bidders cannot submit bids for larger
sets of items. Both of these approaches, as well as hybrid
combinations thereof, were shown to actually further inter-
fere with truthful bidding in some cases (Ausubel and Bara-
nov 2014,2020).
However, Ausubel and Baranov (2019) showed that bas-
ing the clock phase activity rule not on the above but in-
stead entirely upon the generalized axiom of revealed pref-
erence (GARP) can dynamically approximate VCG payoffs
and thus improve the bidding incentives of the CCA. GARP
imposes revealed-preference constraints (see Definition A.5)
to the bidder’s demand responses, i.e., the GARP activity
rule requires the bidder to exhibit rational behaviour in her
demand choices. Importantly, the GARP activity rule does
not require a monotonic price trajectory. Thus, it can also be
applied in our ML-powered clock phase, allowing the clock
phase of our ML-CCA to enjoy the same improvement in
bidding incentives.
For the supplementary round, the CCA’s most prominent
activity rules are again based on a combination of the same
points-based system and revealed-preference ideas. For this,
we need to define the following constraint:
Definition A.5. (REV EALED -PREFERENCE CONSTRAINT)
The revealed-preference constraint for bundle x∈Xwith
respect to clock round ris
bi(x)≤bi(xr) + ⟨pr, x −xr⟩,(16)
where bi(x)∈R≥0is bidder i’s bid for bundle x∈Xin
the supplementary round, xr∈ X is the bundle demanded
by the agent at clock round r,bi(xr)∈R≥0is the final bid
for bundle xr∈ X and pr∈Rm
≥0is the linear price vector
of clock round r.
Intuitively, the revealed-preference constraint states that a
bidder is not allowed to claim a high value for bundle x∈ X
relative to bundle xr∈ X , given that she claimed to prefer
bundle xr∈ X at clock round r(see Inequality (6)). The
difference between the three most prominent supplementary
round activity rules is with respect to which clock rounds the
revealed-preference constraint should be satisfied. Specifi-
cally:
1. Final Cap: A bid for bundle x∈ X should satisfy the
revealed-preference constraint (Definition A.5)with re-
spect to the final clock round’s price pQmax ∈R≥0and
bundle xQmax ∈ X .
2. Relative Cap: A bid for bundle x∈ X should satisfy
the revealed-preference constraint (Definition A.5)with
respect to the last clock round for which the bidder was
eligible for that bundle x∈ X , based on the points-based
system.
3. Intermediate Cap: A bid for bundle x∈ X should satisfy
the revealed-preference constraint (Definition A.5)with
respect to all eligibility-reducing rounds, starting from
the last clock round for which the bidder was eligible for
x∈ X based on the point system.
Ausubel and Baranov (2017) showed that combining the
Final Cap and Relative Cap activity rules leads to the largest
amount of reduction in bid-sniping opportunities for the UK
4G auction, as measured by the theoretical bid amount that
each bidder would need to increase her bid by in the sup-
plementary round in order to protect her final clock round
bundle. Finally, note that the Final- and Intermediate Cap
activity rules can also be applied to our ML-CCA.7
To conclude, we observe that for both its clock phase and
the supplementary round, our ML-CCA (with the same Finit
method as the CCA), is compatible with the most promi-
nent activity rules for the corresponding phases of the CCA,
while it is also obviously compatible with the most promi-
nent payment rule, VCG-nearest prices (Definition A.4).
This, combined with the fact that the ML-CCA has the same
interaction paradigm for the bidders as the CCA, is a very
strong indication that our ML-CCA can reduce the opportu-
nities for the bidders to misreport to a similar extent as the
classical CCA.
B Multiset MVNNs
B.1 Advantages of mMVNNs over MVNNs
In Weissteiner and Seuken (2020) and Weissteiner et al.
(2022b,a,2023) items with a capacity ck, were treated as
ckdistinct items, without exploiting the prior knowledge
that these ckitems are indistinguishable to the bidders.
Sufficiently large classical MVNNs that were trained on
large enough training sets would at some point learn that
these items are indistinguishable, but this prior information
was not incorporated at an architectural level. For multiset
MVNNs (mMVNNs) this prior knowledge is hard-coded di-
rectly into the architecture (see Definition 1). This additional
prior knowledge is particularly beneficial for small training
data sets in terms of generalization. At the same time, it can
significantly reduce the dimensionality of the input space, as
Example B.1 illustrates.
Example B.1. If we have 30 different items each of ca-
pacity 2 (i.e., X={0,1,2}30), then then the bundle x=
(1,...,1) ∈ X containing one of each 30 items would have
230 >1billion different representations as sets correspond-
ing to binary vectors in ˜
X={0,1}60 (where the items
are treated as 60 items of capacity 1). All these 230 repre-
sentations in ˜
Xcould be mapped to different values by a
classical MVNN ˜
Mθ
i:˜
X → R≥0, while we actually have
the hard prior knowledge that they should all have exactly
the same value due to indistinguishable items. And all these
230 representations in ˜
Xcorrespond to the same multiset
7With the modification for the Relative Cap rule that the
revealed-preference constraint should hold for the Qinit rounds that
follow the same price update rule as the CCA, and then the ML-
powered clock rounds should be treated as corresponding to the
same amount of points, since the prices in these rounds on aggre-
gate stay very close to the prices of the last Qinit round, as shown
in Figures 5to 8.
12

x= (1,...,1) ∈ X , which gets assigned to exactly one
value Mθ
i(x)by an mMVNN Mθ
i:X → R≥0.
Furthermore, the solution times of MILPs are likely
to benefit from the mMVNNs’ reduced variable count
compared to traditional MVNNs. In the case of classical
MVNNs, it was necessary to introduce one binary variable
for each indistinguishable duplicate of an item, resulting in
˜m=Pm
k=1 ck. In contrast, mMVNNs require only minte-
ger variables. For an experimental comparison of mMVNNs
to MVNNs, see Appendix D.10.
B.2 Universality of mMVNNs
Note that Weissteiner et al. (2022a) have proven universality
of MVNNs only for the case of binary input vectors corre-
sponding to classical sets (i.e., ck= 1 ∀k∈M). Here, we
prove in Appendix B.2 universality of mMVNNs for arbi-
trary capacities c∈Nmcorresponding to multiset domains
such as our X.
First, we recall the following definition:
Definition B.1. The set Vof all monotonic8and normalized
functions from Xto R≥0is defined as
V:= {vi:X → R+|satisfy (N) and (M)}.(17)
The following lemma says that every mMVNN is mono-
tonic (M) and and normalized (N) in the sense of Defini-
tion B.1.
Lemma 1. Let Mθ
i:X → R+be an mMVNN from Defini-
tion 1. Then it holds that M(Wi,bi)
i∈ V for all Wi≥0and
bi≤0.
Proof. The proof of this lemma is perfectly analogous to
the proof of (Weissteiner et al. 2022a, Lemma 1).
Now we are ready to present a constructive proof for The-
orem 1.
Proof of Theorem 1
Proof. This proof follows a similar strategy as the proof of
(Weissteiner et al. 2022a, Theorem 1).
1. V ⊇ nM(Wi,bi)
i:Wi,k ≥0, bi,k ≤0∀k∈ {1,...,Ki}o
This direction follows immediately from Lemma 1.
2. V ⊆ nM(Wi,bi)
i:Wi,k ≥0, bi,k ≤0∀k∈ {1,...,Ki}o
Let (vi(x))x∈X ∈ V. For the reverse direction, we give
a constructive proof, i.e., we construct an mMVNN Mθ
i
with θ= (Wi
vi, bi
vi)i∈{1,...,4}such that Mθ
i(x) = vi(x)
for all x∈ X .
8Within this paper, by “monotonic”, we always refer to
weakly monotonically increasing (M), i.e., monotonically non-
decreasing. In multiset-notation this reads as: ∀a, b ∈ X :
(a⊆b=⇒vi(a)≤vi(b)).
Let (wj)|X |
j=1 denote the values corresponding to
(vi(x))x∈X of all |X | =Qm
j=1(cj+ 1) possible bun-
dles x∈ X sorted by value in increasing order, i.e, let
x1= (0,...,0) with
w1:= vi(x1) = 0,(18)
let x|X | =c= (c1, . . . , cm)with
w|X | := vi(x|X | ),(19)
and xj, xl∈ X \ {x1, x|X | }for 1< l ≤j≤ |X | − 1
with
wj:= vi(xj)≤wl:= vi(xl).(20)
In the following, for xl, xj∈ X , we use the notation
xl≤xjiff xl,k ≤xj,k ∀k∈M. Thus, we write xl≤
xjiff ∃k∈M:xl,k > xj,k, i.e., iff xl≤xjis not
the case.9Furthermore, we denote by ⟨·,·⟩ the Euclidean
scalar product on Rm. Then, for all x∈ X :
vi(ξ) =
|X |−1
X
l=1
(wl+1 −wl)
1
{∀j∈{1,...,l}:ξ≤xj}(21)
=
|X |−1
X
l=1
(wl+1 −wl)φ0,1 l
X
j=1
φ0,1 m
X
k=1
φ0,1(ξk−xj,k)!−(l−1)!,
(22)
where the second equality follows since
ξ≤ xj⇐⇒ ∃k∈M:ξk> xj,k (23)
⇐⇒ ∃k∈M:φ0,1(ξk−xj,k ) = 1 (24)
⇐⇒ φ0,1 m
X
k=1
φ0,1(ξk−xj,k)!= 1,(25)
which implies that
(∀j∈ {1, . . . , l}:ξ≤ xj)
⇐⇒
l
X
j=1
φ0,1 m
X
k=1
φ0,1(ξk−xj,k)!=l, (26)
and
1
{∀j∈{1,...,l}:x≤xj}
=φ0,1

l
X
j=1
φ0,1 m
X
k=1
φ0,1(ξk−xj,k)!−(l−1)
.
(27)
To match the structure of the mMVNN architecture de-
fined in Definition 1, we can write vi(ξ) = vi(D−1Dξ)
and plug in D−1Dξ instead of ξin Equation (22).10
9Note, that in the multidimensional case m > 1, the two sym-
bols ≤ and >have a different meaning, i.e., xl> xj⇐⇒
(xl≤ xjand xl≥xj). Further note that <,≤and ≤ exactly cor-
respond to ⊂,⊆and ⊆ respectively in multiset notation.
10The diagonal matrix D:= diag (1
/c1,...,1
/cm)is invertible
with D−1= diag (c1,...,cm), since all capacities ciare strictly
larger than 0.
13

Equation (22) can be rewritten as the following mMVNN
Mθ
i(x) =
Wi,4
viφ0,1Wi,3
viφ0,1Wi,2
viφ0,1Wi,1
viDξ +bi,1
vi+bi,2
vibi,3
vi
+bi,4
vi(28)
in the matrix-notation of Definition 1with weight matri-
ces and bias-vectors be given as:
Wi,1
vi:= 


D−1
.
.
.
D−1

∈Rm(|X |−1)×m,(29)
bi,1
vi:= −



x1
x2
.
.
.
x|X |−1



∈Rm(|X |−1),(30)
Wi,2
vi:= 






m
z }| {
1,...,1
m
z }| {
0,...,0. . .
m
z }| {
0,...,0
0,...,0 1,...,1....
.
.
.
.
.......0,...,0
0,...,0. . . 0,...,0 1,...,1







∈R(|X |−1)×m(|X |−1),
(31)
bi,2
vi:= 0 ∈R|X |−1,(32)
Wi,3
vi:= 




1 0 . . . 0
.
.
........
.
.
.
.
....0
1. . . . . . 1





∈R(|X |−1)×(|X |−1),(33)
bi,3
vi:= 



0
−1
.
.
.
−(|X | − 2)



∈R|X |−1,(34)
Wi,4
vi:= 



w2−w1
w3−w2
.
.
.
w|X | −w|X |−1




⊤
∈R1×(|X |−1),(35)
bi,4
vi:= 0 ∈R,(36)
where Wi,2
vi=
1
{(j−1)m<k≤jm}1≤j≤|X |−1,1≤k≤m(|X |−1)
is an alternative notation to describe Equation (31). Thus,
Mθ
i(x)is an mMVNN from Definition 1with 6 layers in
total (i.e., 1 input layer, 1 linear normalization layer D, 3
non-linear hidden layers and 1 output layer) and respec-
tive dimensions [m, m, m(|X | − 1),|X | − 1,|X | − 1,1].
Remark B.1 (Normalization Layer).Note that our proof of
Theorem 1would also work without the linear normalization
layer D. The normalization layer has the advantage that we
can use similar hyperparameters as for classical MVNNs.
E.g., we can use the same values of the parameters in the
initialization scheme as provided in Weissteiner et al. (2023,
Section 3.2 and Appendix E).
Remark B.2 (Number of Hidden Layers).Note that for
binary input vectors (corresponding to classical sets, i.e.,
c= (1,...,1)), 2 non-linear hidden layers were suffi-
cient (Weissteiner et al. 2022a, Proof of Theorem 1), while
for integer-valued input vectors (corresponding to multisets
with capacities c∈Nm), we used 3 non-linear hidden layers
for our proof of Theorem 1. It is an interesting open question
if 2 non-linear hidden layers would already be sufficient also
for our multiset setting with capacities c∈Nm.11
Remark B.3 (Number of Hidden Neurons).The dimension
[m, m, m(|X | − 1),|X | − 1,|X | − 1,1] of the mMVNN used
in the proof of Theorem 1is just an upper bound. This proof
does not imply that such large networks are actually needed.
From a theoretical perspective it is interesting that this up-
per bound is finite, while for NNs on continuous domains no
finite upper bound for perfect approximation exits. In prac-
tice much smaller networks are usually sufficient. All the re-
sults reported in this paper were achieved by much smaller
networks with at most 30 neurons per layer (see Table 2in
Appendix D.3).
C ML-powered Demand Query
Generation:Theoretical Results
In this section, we prove Theorems 2and 3.
C.1 Proof of Theorem 2
In this subsection, we first present and prove in Lemma 2an
unconstrained version of Theorem 2, which we later use to
prove our main statement from Theorem 2.
Lemma 2extends (Bikhchandani and Ostroy 2002, The-
orem 3.1.). Concretely, we additionally show that if linear
clearing prices exist, every minimizer of Wis a clearing
price (while Bikhchandani and Ostroy (2002, Theorem 3.1.)
only showed that every clearing price pminimizes Wnot
specifying if there could be other minimizers of Wwhich
are not clearing prices).
Lemma 2. Consider the notation from Definitions 2
and 3and the objective function W(p, v):=R(p) +
Pi∈NU(p, vi). Then it holds that, if a linear clearing price
exists, every price vector
p′∈argmin
˜p∈Rm
≥0
W(˜p, v)(37)
is a clearing price and the corresponding allocation a(p′)∈
Fis efficient.
Proof of Lemma 2.We first show in Item 1that for clear-
ing prices p∈Rm
≥0, the corresponding allocation a(p)∈
11Our proof of Theorem 1works with 1 input layer, 1 linear
normalization layer D(which is optional, see Remark B.1), 3 non-
linear hidden layers and 1 output layer (i.e., 5 or 6 layers in total).
Whereas the (Weissteiner et al. 2022a, Proof of Theorem 1) only
required 1 input layer, 2 non-linear hidden layers and 1 output layer
(i.e., 4 layers in total).
14

Fis efficient. Next, in Item 2we show that every lin-
ear clearing price p∈Rm
≥0minimizes W, i.e., formally
p∈argmin˜p∈Rm
≥0W(˜p, v). Finally, in Item 3we show that
if linear clearing prices exist, any minimizer of Wis in fact
a linear clearing price.
1. Let (p, a(p)) ∈Rm
≥0× F be clearing prices and the cor-
responding supported allocation (see Definition 3). Fur-
thermore, let ˜a∈ F be any other feasible allocation.
Then it holds that:
n
X
i=1
vi(ai(p)) = (38)
n
X
i=1
[vi(ai(p)) − ⟨p, ai(p)⟩] +
n
X
i=1
⟨p, ai(p)⟩=(39)
n
X
i=1
U(p, vi)!+R(p)≥(40)
n
X
i=1
[vi(˜ai)− ⟨p, ˜ai⟩] +
n
X
i=1
⟨p, ˜ai⟩=(41)
n
X
i=1
vi(˜ai),(42)
where the first inequality follows since (p, a(p)) are
clearing prices and fulfill Items 1and 2in Definition 3
and because ˜a∈ F is another feasible allocation. This
shows that a supported allocation a(p)is efficient.
2. Let (p, a(p)) ∈Rm
≥0× F be clearing prices and the cor-
responding supported allocation (see Definition 3). Fur-
thermore, let ˜p∈Rm
≥0be any other linear prices. Then it
holds that:
W(p, v) = (43)
max
a∈F (n
X
i=1
⟨p, ai⟩)+
n
X
i=1
max
x∈X {vi(x)− ⟨p, x⟩} =
(44)
n
X
i=1
⟨p, ai(p)⟩+
n
X
i=1
[vi(ai(p)) − ⟨p, ai(p)⟩] = (45)
n
X
i=1
vi(ai(p)) = (46)
n
X
i=1
⟨˜p, ai(p)⟩+
n
X
i=1
[vi(ai(p)) − ⟨˜p, ai(p)⟩]≤(47)
max
a∈F (n
X
i=1
⟨˜p, ai⟩)+
n
X
i=1
max
x∈X {vi(x)− ⟨˜p, x⟩} =
(48)
W(˜p, v),(49)
where Equation (44) follows by definition of Wand
Equation (45) follows since (p, a(p)) are clearing prices
and the corresponding supported allocation, respectively
Thus, we get that
W(p, v)≤W(˜p, v),(50)
for all linear prices ˜p∈Rm
≥0, which concludes the proof.
3. Let p′∈argmin˜p∈Rm
≥0W(˜p, v)be a minimizer of W.
Moreover, let p∈Rm
≥0denote a linear clearing price
and let a(p)∈ F be the corresponding supported al-
location (see Definition 3). Furthermore, let x∗
i(p′)∈
argmaxx∈X {vi(x)− ⟨p′, x⟩} ∀i∈N. We know from
Item 2that W(p′, v) = W(p, v). Furthermore, we get
that
n
X
i=1
vi(x∗
i(p′)) −
n
X
i=1
⟨p′, x∗
i(p′)⟩+⟨p′, c⟩=(51a)
W(p′, v) = W(p, v) = (51b)
n
X
i=1
vi(ai(p)) −
n
X
i=1
⟨p, ai(p)⟩+⟨p, c⟩(45)
=(51c)
n
X
i=1
vi(ai(p)) = (51d)
n
X
i=1
vi(ai(p)) −
n
X
i=1
⟨p′, ai(p)⟩+⟨p′, c⟩,(51e)
where the last equation follows since a(p)is a clearing
allocation supported by pand thus Pn
i=1 ⟨p′, ai(p)⟩=
⟨p′, c⟩. Next, we can subtract ⟨p′, c⟩from both sides of
Equation (51) to obtain
n
X
i=1
vi(x∗
i(p′)) − ⟨p′, x∗
i(p′)⟩=
n
X
i=1
vi(ai(p)) − ⟨p′, ai(p)⟩.(52)
Moreover, from the optimality of x∗
i(p′)it follows that
vi(x∗
i(p′)) − ⟨p′, x∗
i(p′)⟩ ≥ vi(ai(p)) − ⟨p′, ai(p)⟩,
(53)
holds for every i∈ {1, . . . , n}.
Using now Equations (52) and (53), it follows that for
every i∈ {1, . . . , n}
U(p′, vi) = vi(x∗
i(p′)) − ⟨p′, x∗
i(p′)⟩=(54)
vi(ai(p)) − ⟨p′, ai(p)⟩.(55)
Taken all together, since Pi∈N⟨p′, ai(p)⟩=
Pj∈Mp′
j, cj=R(p′)and U(p′, vi) =
vi(ai(p)) − ⟨p′, ai(p)⟩for all i∈N, we can con-
clude that (p′, a(p)) ∈Rm
≥0× F by Definition 3is
a linear clearing price with corresponding supported
allocation a(p)∈ F. This finalizes the proof of
Lemma 2.
Now, we are ready to prove Theorem 2, which follows
almost immediately from Lemma 2.
Proof of Theorem 2.Let p′be a solution to the constrained
minimization problem defined by Equation (9). Moreover,
15

let p∈Rm
≥0denote a linear clearing price vector and let
a(p)∈ F be the corresponding supported allocation (see
Definition 3).
In Item 2in the proof of Lemma 2, we have seen that
pminimizes Wwithout any constraints. The clearing price
vector pobviously satisfies constraint (9b), thus pis also a
solution to the constrained optimization problem (9). There-
fore, in the case that linear clearing prices exist the mini-
mal objective value of the constrained optimization problem
from (9) is equal to the minimal objective value of the un-
constrained minimization problem (37). From this we can
conclude that in the case that linear clearing prices exist, ev-
ery solution p′of (9) is also a solution of the optimization
problem (37). Finally, Lemma 2tells us that every solution
p′of the optimization problem (37) is a clearing price and
a(p′)is efficient.
In Theorem 2we proved that the constraint minimizer of
Whas the same economical favourable properties as the un-
constrained minimizer of Wif linear clearing prices exist.
Thus, we do not lose anything in cases where linear clearing
prices exist, while due to the constraint (9b) we have the ad-
vantage of receiving feasible allocations in the case that no
linear clearing price exist.
C.2 Details: Proof of Theorem 3
Before we start with the proof, we will quickly provide a
proof for Equation (8), since this equation (that we have not
explicitly proven in the main paper) is essential in the proof
of Theorem 3.
Proof of Equation (8).
R(p):= max
a∈F (X
i∈N
⟨p, ai⟩)(56)
= max
a∈F 

X
i∈NX
j∈M
pjai,j 


(57)
= max
a∈F 

X
j∈MX
i∈N
pjai,j 


(58)
= max
a∈F 

X
j∈M
pjX
i∈N
ai,j 


(59)
= max 

X
j∈M
pjX
i∈N
ai,j :X
i∈N
ai,j ≤cj∀j∈M


(60)
=X
j∈M
pjcj=X
j∈M
cjpj=⟨c, p⟩.(61)
In the first lemma we prove that p7→ W(p, Mθ
in
i=1)
is Lipschitz-continuous. While neither p7→ x∗
i(p), nor
p7→ Mθ
i(x∗
i(p)) nor p7→ ⟨p, x∗
i(p)⟩are continuous, (sur-
prisingly) p7→ Mθ
i(x∗
i(p)) + ⟨p, x∗
i(p)⟩is continuous.
Lemma 3 (Continuity).The map p7→ Wp, Mθ
in
i=1
from Rm
≥0to R≥0is Lipschitz-continuous with Lipschitz-
constant (n+ 1) ∥c∥2.12
Proof. Since Wp, Mθ
in
i=1:=R(p) +
Pi∈NUp, Mθ
iis the sum of 1 + nfunctions, we
first quickly show that Ris Lipschitz-continuous in pand
afterwards we will show that also Uis Lipschitz-continuous
in p.
From Equation (8) it follows that R(p) = P
j∈M
cjpjis
linear in pand thus Lipschitz-continuous with Lipschitz-
constant ∥c∥2.
In the remainder of the proof we are going to show
that Up, Mθ
i:= max
x∈X Mθ
i(x)− ⟨p, x⟩is Lipschitz-
continuous in p. Let p, ˜p∈Rm
≥0be two price vectors, then
we have
U˜p, Mθ
i≥ Mθ
i(ˆx∗
i(p)) + ⟨˜p, ˆx∗
i(p)⟩(62)
=Mθ
i(ˆx∗
i(p)) + ⟨˜p+p−p, ˆx∗
i(p)⟩(63)
=Mθ
i(ˆx∗
i(p)) + ⟨p, ˆx∗(p)⟩+⟨˜p−p, ˆx∗
i(p)⟩
(64)
=Up, Mθ
i+⟨˜p−p, ˆx∗
i(p)⟩(65)
≥Up, Mθ
i− ∥˜p−p∥2∥ˆx∗
i(p)∥2(66)
≥Up, Mθ
i− ∥˜p−p∥2∥c∥2,(67)
and thus
U˜p, Mθ
i−Up, Mθ
i≥ − ∥ ˜p−p∥2∥c∥2.(68)
By exchanging the roles of pand ˜p, we also obtain
Up, Mθ
i≥U˜p, Mθ
i− ∥˜p−p∥2∥c∥2and thus,
U˜p, Mθ
i−Up, Mθ
i≤ ∥˜p−p∥2∥c∥2.(69)
Finally, Equations (68) and (69) together imply
U˜p, Mθ
i−Up, Mθ
i≤ ∥ ˜p−p∥2∥c∥2.(70)
Equation (70) by definition says that Uis Lipschitz-
continuous in pwith Lipschitz-constant ∥c∥2.
So, we finally obtain, that Wis Lipschitz-continuous in p
with Lipschitz-constant (n+ 1) ∥c∥2.
Lemma 4 (Convexity).The map p7→ Wp, Mθ
in
i=1
from Rm
≥0to R≥0is convex.13
Proof. Since Wp, Mθ
in
i=1:=R(p) +
Pi∈NUp, Mθ
iis the sum of 1 + nfunctions, we
first quickly show that Ris obviously convex in pand
afterwards we will show that also Uis convex in p.
12Note that Lipschitz-continuity implies (uniform) continuity.
The Lipschitz-constant (n+ 1) ∥c∥2, given in the proof, only de-
pends on the capacities cof Xand on the number of bidders n.
The proof also works for any other (possibly non-monotonic) value
function vi:X → Rinstead of Mθ
i.
13The proof also works for any other (possibly non-monotonic)
value function vi:X → Rinstead of Mθ
i.
16

From Equation (8) it follows that R(p) = P
j∈M
cjpjis
linear in pand thus convex in p.
In the remainder of the proof we are going to show
that Up, Mθ
i:= max
x∈X Mθ
i(x)− ⟨p, x⟩is convex in
p. For every i∈Nand for every x∈ X , the map p7→
Mθ
i(x)− ⟨p, x⟩is (affine-)linear14 in pand thus convex in
p. As the maximum over convex functions is always con-
vex (Danskin 1967;Bertsekas 1971,1999), Up, Mθ
i:=
max
x∈X Mθ
i(x)− ⟨p, x⟩is convex in p.
So finally we get that Wis convex in p, since it is the sum
of (n+ 1) convex functions.
Lemma 5 (Sub-gradients).Let ˆ
X∗
i(p) :=
argmaxx∈X Mθ
i(x)− ⟨p, x⟩denote the set of util-
ity maximizing bundles w.r.t. Mθ
ifor the i-th bidder. Then
the sub-gradients of the map p7→ Wp, Mθ
in
i=1from
Rm
≥0to R≥0are given by
∇sub
pW(p, Mθ
in
i=1)
:= conv (c−X
i∈N
ˆx∗
i(p) : (ˆx∗
i(p))i∈N∈×
i∈N
ˆ
X∗
i(p)),
(71)
where conv denotes the convex hull and ×denotes the
Cartesian product. In particular, for each (ˆx∗
i(p))i∈N∈
×i∈Nˆ
X∗
i(p),
c−X
i∈N
ˆx∗
i(p)∈ ∇sub
pW(p, Mθ
in
i=1)(72)
is asubgradient of Wwith respect to p.15
Proof. Since Wp, Mθ
in
i=1:=R(p) +
Pi∈NUp, Mθ
iis the sum of 1 + nfunctions, we
first quickly compute the (sub-)gradient of Rwith respect
to pand afterwards we will compute the sub-gradients of U
with respect to p.
From Equation (8) it follows that R(p) = P
j∈M
cjpjis
linear in pand thus its sub-gradient is uniquely defined as its
gradient ∇pR(p) = c, i.e., ∇sub
pR(p) = {c}.
In the remainder of the proof we are going to
compute the set of sub-gradients of Up, Mθ
i:=
max
x∈X Mθ
i(x)− ⟨p, x⟩with respect to pwith the help of
Danskin’s theorem (originally proven by Danskin (1967)
and later refined by Bertsekas (1971,1999)). Let’s de-
fine ϕi(p, x) := Mθ
i(x)− ⟨p, x⟩. Then Up, Mθ
i=
max
x∈X ϕi(p, x)and ˆ
X∗
i(p) = argmax
x∈X
ϕi(p, x). Next, we show
that ϕi:Rm
≥0× X → Rfulfills all the assumptions of Dan-
skin’s theorem:
14In the following, we will call affine-linear functions “linear”
too as commonly done in the literature.
15The proof also works for any other (possibly non-monotonic)
value function vi:X → Rinstead of Mθ
i.
• For every x∈ X the map p7→ ϕi(p, x)is convex and
differentiable, since it is (affine-)linear.
• For every p∈Rm
≥0the map x7→ ϕi(p, x)is continuous,
since Xis discrete and every function is continuous with
respect to the discrete topology.
• Furthermore, the set Xis compact (since it is finite).
Under these three assumptions Danskin’s theorem tells us
that
∇sub
pUp, Mθ
i= conv n∇pϕi(p, x) : x∈ˆ
X∗
i(p)o.(73)
Now we can simply compute ∇pϕi(p, x)for any constant
x∈ X , i.e.,
∇pϕi(p, x) = ∇pMθ
i(x)− ⟨p, x⟩(74a)
=∇pMθ
i(x)− ∇p⟨p, x⟩(74b)
= 0 −x=−x. (74c)
Plugging in Equation (74) into Equation (73) results in
∇sub
pUp, Mθ
i= conv n−x:x∈ˆ
X∗
i(p)o.(75)
Note that set of sub-gradients of a sum of real-valued16
convex functions, is equal to the sum17 of the sets of sub-
gradients of the individual functions (Rockafellar 1970,
Theorem 23.8). Further note that the sum of convex hulls
of sets is equal to the convex hull of their sum. We use these
two insights and Equation (75) to finally compute the set of
sub-gradients
∇sub
pW(p, Mθ
in
i=1) = (76a)
=∇sub R(p) + X
i∈N
Up, Mθ
i!(76b)
=∇subR(p) + X
i∈N
∇subUp, Mθ
i(76c)
={c}+X
i∈N
conv n−x:x∈ˆ
X∗
i(p)o(76d)
={c}+ conv X
i∈Nn−x:x∈ˆ
X∗
i(p)o(76e)
={c} − conv X
i∈N
ˆ
X∗
i(p)(76f)
={c} − conv (X
i∈N
ˆx∗
i(p) : (ˆx∗
i(p))i∈N∈×
i∈N
ˆ
X∗
i(p))
(76g)
= conv (c−X
i∈N
ˆx∗
i(p) : (ˆx∗
i(p))i∈N∈×
i∈N
ˆ
X∗
i(p)),
(76h)
16Note that Rockafellar (1970, Theorem 23.8) is formulated for
proper convex functions with overlapping effective domains that
can potentially attain +∞as value. In our case of real-valued func-
tion (which implies that they cannot attain +∞) all convex func-
tions are proper and their effective domain is simply their domain.
17The (Minkowski) sum of two sets Aand Bis defined as the
set A+B={a+b: (a, b)∈A×B}of all possible sums of any
element of the first set Aand any element of the second set B.
17

which proves the main statement (71) of Lemma 5. This di-
rectly implies that for each (ˆx∗
i(p))i∈N∈×i∈Nˆ
X∗
i(p),
c−X
i∈N
ˆx∗
i(p)∈ ∇sub
pW(p, Mθ
in
i=1)(77)
is an element of the convex hull in (76h) and thus a sub-
gradient of Wwith respect to p.
Next, Lemma 6shows that the map p7→
Wp, Mθ
in
i=1from Rm
≥0to R≥0is Lebesgue-almost
everywhere differentiable with (proper) gradient18
∇pW(p, Mθ
in
i=1)a.e.
=c−X
i∈N
ˆx∗
i(p),(78)
where ˆx∗
i(p)∈ˆ
X∗
i(p) := argmaxx∈X Mθ
i(x)− ⟨p, x⟩
denotes the utility maximizing bundle w.r.t. Mθ
ifor the i-th
bidder, which is Lebesgue-almost everywhere unique.
Lemma 6 (A.e. Differentiable).Let Mθ
in
i=1 be a tuple of
mMVNNs. Then there exists a dense19 subset P⊆Rm
≥0such
that Rm
≥0\Pis a Lebesgue null set20, and that ∀p∈P:
1. A unique optimizer ˆx∗
i(p)∈ˆ
X∗
i(p)exists, i.e.,
{x∗
i(p)}=ˆ
X∗
i(p) := argmax
x∈X Mθ
i(x)− ⟨p, x⟩(79)
and
2. the map p7→ Wp, Mθ
in
i=1is differentiable with gra-
dient
∇pW(p, Mθ
in
i=1) = c−X
i∈N
ˆx∗
i(p),(80)
which is also the unique sub-gradient, i.e.
c−Pi∈Nˆx∗
i(p)=∇sub
pW(p, Mθ
in
i=1).
3. The unique optimizer ˆx∗
i(p)is constant in a local neigh-
borhood of p, and thus ∂pˆx∗
i(p)=0.21
Proof. We start this proof by defining Pand showing
a.e. differentiability. Since Wp, Mθ
in
i=1:=R(p) +
Pi∈NUp, Mθ
iis the sum of 1 + nfunctions, we first
quickly show that Ris obviously differentiable and after-
wards we show that each Up, Mθ
iis differentiable on a
set Pi. Afterwards we will define Pas their intersection.
From Equation (8) it follows that R(p) = P
j∈M
cjpjis
linear in pand thus differentiable.
18Note that the gradient in Equations (78) and (80) actually de-
notes a classical gradient and not just a sub-gradient.
19The set Pbeing dense means that its topological closure P
covers the whole space, i.e., P=Rm
≥0.
20The set Rm
≥0\Pbeing a (Lebesgue) null set means that its
m-dimensional Lebesgue measure (i.e., the m-dimensional vol-
ume) λmRm
≥0\P= 0. Within this work “a.e.” always corre-
sponds to “Lebesgue almost everywhere”.
21Note that one could even prove that the gradient is continuous
on P, while the gradient can have jumps at the null set Rm
≥0\P.
The proof also works for any other (possibly non-monotonic) value
function vi:X → Rinstead of Mθ
i.
Next, we show that Up, Mθ
i:=
max
x∈X Mθ
i(x)− ⟨p, x⟩is differentiable a.e. and de-
fine Pi. We know already from the proof of Lemma 4that
Up, Mθ
iis convex and Rockafellar (1970, Theorem 25.5
on p. 246) tells us that for any22 real-valued convex function
there exists a dense set Pion which the functions is
differentiable with the complement of Pibeing a null set.
Thus, for each p7→ Up, Mθ
i, i ∈N, we obtain such
aPi. If 1 + n∈Nfunctions are differentiable at a point
p, then their sum is too. Thus, p7→ Wp, Mθ
in
i=1
is differentiable on P:= Tn
i=1 Pi. Since each Piis
dense in Rm
≥0,Pis also dense in Rm
≥0. Moreover, it
holds that λmRm
≥0\P=λmSn
i=1(Rm
≥0\Pi)≤
Pn
i=1 λmRm
≥0\Pi=Pn
i=1 0 = 0, i.e., the m-
dimensional Lebesgue measure of Rm
≥0\Pvanishes. Putting
everything together, we get that p7→ Wp, Mθ
in
i=1is
a.e. differentiable (concretely differentiable for all p∈P).
Next, we prove the uniqueness of ˆx∗
i(p)∈ˆ
X∗
i(p)for
every p∈Pi⊇P. We know that p7→ Up, Mθ
iis differ-
entiable at p∈Pi, and thus we know that the sub-gradient
is unique, i.e., ∇sub
pUp, Mθ
i=∇pUp, Mθ
i= 1.
We have already computed this set of sub-gradients
∇sub
pUp, Mθ
i= conv n−x:x∈ˆ
X∗
i(p)o=
conv −ˆ
X∗(p)⊇ − ˆ
X∗(p)in Equation (75) in the proof of
Lemma 5. This set can only be a singleton, if ˆ
X∗(p)is a
singleton. Finally, ˆ
X∗(p)= 1 immediately implies Item 1,
i.e., the uniqueness of ˆx∗
i(p)∈ˆ
X∗
i(p).
Using that p7→ Up, Mθ
iis differentiable for every
p∈Ptogether with Item 1and Lemma 5, we finally ob-
tain Item 2for every p∈P.
For Item 3it is crucial that Xis finite. For every p∈P, we
know from Item 1that there is a unique maximizer ˆx∗
i(p)∈
ˆ
X∗
i(p) = argmax
x∈X
ϕi(p, x)with ϕi(p, x) := Mθ
i(x)−⟨p, x⟩.
Since Xis finite, we can define
ϵi(p) := ϕi(p, ˆx∗
i(p)) −max
x∈X \{ˆx∗
i(p)}ϕi(p, x),(81)
which has to be strictly larger than 0 for every p∈Pbecause
of the uniqueness of the maximizer. Equation (81) implies
that ˆx∗
i(p)outperforms every other x∈ X by at least a mar-
gin of ϵi(p). Since ϕiis continuous, ˆx∗
i(p)cannot be “over-
taken” by any other x∈ X within a small neighbourhood of
pas we will calculate explicitly in the following using the
Lipschiz constant ∥c∥2of ϕithat we derived in the proof of
22There are some very mild technical assumptions in Rockafellar
(1970, Theorem 25.5 on p. 246) that do not matter in our case.
Rockafellar (1970) assumes that the function is defined on Rm. In
our case we could easily extend the domain of our function from
Rm
≥0to Rm.AsRockafellar (1970, Theorem 25.5 on p. 246) is
formulated for proper convex functions that can also attain +∞
one could extend any convex function from a convex domain (such
as Rm
≥0) to be defined to be +∞outside of that convex domain.
Note that if Piis dense in Rm
>0it is also dense in Rm
≥0and that
λmRm
≥0\Rm
>0= 0.
18

Lemma 3: For any x∈ X \ { ˆx∗
i(p)}, p ∈P, ˜p∈Rm
≥0, we
have
ϕi(˜p, x)≤ϕi(p, x) + ∥c∥2∥˜p−p∥2(82a)
≤max
x∈X \{ˆx∗
i(p)}ϕi(p, x) + ∥c∥2∥˜p−p∥2(82b)
≤ϕi(p, ˆx∗
i(p)) −ϵi(p) + ∥c∥2∥˜p−p∥2(82c)
≤ϕi(˜p, ˆx∗
i(p)) −ϵi(p)+2∥c∥2∥˜p−p∥2.
(82d)
From this inequality we obtain, that within an open ball with
radius mini∈Nϵi(p)
2∥c∥2>0around p∈P, the optimizers
ˆx∗
i(p)stay constant for every i∈N. Therefore, the differ-
ential ∂pˆx∗
i(p)is zero for all p∈P, which concludes the
proof of Item 3.
Putting everything together, we can finally prove Theo-
rem 3.
Proof of Theorem 3.Combining Lemmas 3to 6proves The-
orem 3(and even slightly stronger statements, e.g., Lemma 5
fully specifies the set of all sub-gradients).
Theorem 3and most of the statements from Lemmas 3
to 6can be proven under even less assumptions as we will
discuss in the following Remarks C.1 and C.2 which gener-
alize the theory to further settings.
Remark C.1 (General Value Functions).Theorem 3and
Lemmas 3to 6are also true for the map p7→
W(w, (gi)n
i=1), with any (possibly non-monotonic) value
function gi:X → Rinstead of gi=Mθ
i, since we never
used any specific properties of MVNNs Mθ
iin the proofs of
these statements. In particular, this includes bidders’ true
value functions gi=vi, vi:X → R.
Remark C.2 (Continuous Input Space ˜
X).Theorem 3and
all of the statements from Lemmas 3to 6except Item 3from
Lemma 6are also true if one replaces the finite set Xby any
(possibly non-discrete) compact set ˜
X(if one extends the
definition of Mθ
iin the natural way from Xto ˜
X ⊆ Rm).
When combining Remarks C.1 and C.2 one has to assume
that the gi:˜
X → Rare continuous for our proof.23 Item 3
from Lemma 6can be violated for compact ˜
X ⊆ Rmif
˜
X=∞.24
Remark C.3 (Piece-wise Linear).In our case of finite X,
one can intuitively see with similar arguments as in the proof
of Lemma 4, that p7→ Wp, Mθ
in
i=1is piece-wise linear
as a sum over a linear function and nfunctions which are
the maxima over finitely many linear functions.
D Experiment Details
In this section, we present all details of our experiments from
Section 6.
23Note that if ˜
Xis finite, every function gi:˜
X → Ris continu-
ous by definition.
24Note that, while Item 3from Lemma 6was used for the intu-
itive sketch of the proof of Theorem 3in the main paper, Item 3
from Lemma 6is not necessary at all for the mathematical rigorous
proof of Theorem 3given in Appendix C.2.
D.1 SATS Domains
In this section, we provide a more detailed overview of the
four SATS domains, which we use to experimentally evalu-
ate ML-CCA:
•Global Synergy Value Model (GSVM) (Goeree and Holt
2010) has 18 items with capacities cj= 1 for all j∈
{1,...,18},6regional and 1national bidder. In GSVM
the value of a package increases by a certain percentage
with every additional item of interest. Thus, the value of
a bundle only depends on the total number of items con-
tained in a bundle which makes it one of the simplest mod-
els in SATS. In fact, bidders’ valuations exhibit at most
two-way(i.e., pairwise) interactions between items.
•Local Synergy Value Model (LSVM) (Scheffel, Ziegler,
and Bichler 2012) has 18 items with capacities cj= 1
for all j∈ {1,...,18},5regional and 1national bidder.
Complementarities arise from spatial proximity of items.
•Single-Region Value Model (SRVM) (Weiss, Lubin, and
Seuken 2017) has 3items with capacities c1= 6, c2=
14, c3= 9 and 7bidders (categorized as local,high fre-
quency,regional, or national) and models UK 4G spec-
trum auctions.
•Multi-Region Value Model (MRVM) (Weiss, Lubin, and
Seuken 2017) has 42 items with capacities cj∈ {2,3}for
all j∈ {1,...,42}and 10 bidders (local,regional, or na-
tional) and models large Canadian 4G spectrum auctions.
In the efficiency experiments in this paper, we instantiated
for each SATS domain the 100 synthetic CA instances with
the seeds {101,...,200}. We used SATS version 0.8.1.
D.2 Compute Infrastructure
All experiments were conducted on a compute cluster run-
ning Debian GNU/Linux 10 with Intel Xeon E5-2650 v4
2.20GHz processors with 24 cores and 128GB RAM and
Intel E5 v2 2.80GHz processors with 20 cores and 128GB
RAM and Python 3.8.10.
D.3 Hyperparameter Optimization
In this section, we provide details on our exact HPO method-
ology and the ranges that we used.
We separately optimized the HPs of the mMVNNs for
each bidder type of each domain, using a different set
of SATS seeds than for all other experiments in the pa-
per. Specifically, for each bidder type, we first trained an
mMVNN using as initial data points the demand responses
of an agent of that type during 50 consecutive CCA clock
rounds, and then measured the generalization performance
of the resulting network on a validation set that was created
by drawing 500 price vectors where the price of each item
was drawn uniformly at random from the range of zero to
three times the average maximum value of an agent of that
type for a single item (which was determined using separate
seeds, see validation set 2 in Figure 1). The number of seeds
used to evaluate each model was equal for all models and
set to 10. Finally, for each bidder type we selected the set of
HPs that performed the best on this validation set with re-
spect to the coefficient of determination (R2). The full range
of HPs tested for all agent types and all domains is shown
19

Hyperparameter HPO-Range
Non-linear Hidden Layers [1,2,3]
Neurons per Hidden Layer [8, 10, 20, 30]
Learning Rate (1e-4, 1e-2)
Epochs25 [30, 50, 70, 100]
L2-Regularization (1e-8, 1e-2)
Linear Skip Connections26 [True, False]
Table 2: HPO ranges for all domains.
in Table 2, while the winning configurations are shown in
Table 3.
Additionally, we determined the set of HPs with the best
generalization performance on validation set 2 using as eval-
uation metric a shift-invariant variation of R2, defined as:
R2
c= 1 −Pr((vi(xr)−¯vi)−(Mi(xr)−¯
M))2
Pr(vi(xr)−¯vi)2,(83)
where vi(xr)is the true value of the bidder for the r-th
bundle, Mi(xr)is the neural network’s predicted value for
that bundle, and ¯viand ¯
Miare their empirical means, re-
spectively. The reason that we opted for this shift-invariant
version of R2is that, as explained in Section 3.1, learning
the true value functions of the agents up to a constant shift
suffices for our query generation procedure as described in
Section 4. Surprisingly, in all domains our mechanism per-
formed slightly worse with those HPs, with the maximum
efficiency delta between the two configurations being 1.2%
in LSVM. However, in all domains results were qualitatively
identical. The winning configurations for both metrics are
shown in Tables 3and 4. In all domains we chose the con-
figurations from Table 3for our efficiency experiments.
D.4 Details on mMVNN Training
Remark D.1 (Other ML-models).Note that our train-
ing method TRAINONDQS(Algorithm 1) also works
for any other ML method that can be trained via GD
and for which the inner optimization problem ˆx∗
i(pr)∈
argmaxx∈X nMθt
i(x)− ⟨pr, x⟩o(see Line 4of Algo-
rithm 1) can be solved efficiently. This is the case for
(m)MVNNs, where Line 4can be solved as a MILP analo-
gously to (Weissteiner et al. 2022a). Another example would
be classical ReLU-neural networks (NNs)27, where such a
MILP formulation exists too (Weissteiner and Seuken 2020),
which are suitable for domains without the free disposal
property.
Remark D.2 (Initialization).We use the initialization
scheme introduced by Weissteiner et al. (2023), which offers
25For GSVM and LSVM, the number of epochs was fixed to 30
26For the definition of (m)MVNNs with a linear skip connection,
please see Weissteiner et al. (2023, Definition F.1)
27Note that in principal for every NN with piece-wise linear ac-
tivation function (e.g., ReLU, bReLU or Leaky ReLU) a MILP-
formulation is possible. However for other activation functions
such as the sigmoid activation function an exact MILP-formulation
is not possible.
advantages over the original initialization scheme used by
Weissteiner et al. (2022a) as explained in Weissteiner et al.
(2023, Section 3.2 and Appendix E).
In the conducted experiments, Python 3.8.10 and PyTorch
2.0.0, were employed as the primary programming language
and framework for implementing the mMVNNs. The Adam
optimizer was chosen as the optimization algorithm for the
training process. To further enhance the training procedure,
the cosine annealing scheduler was utilized, dynamically ad-
justing the learning rate over epochs to facilitate conver-
gence and prevent premature stagnation.
D.5 Details MILP Parameters
There are three distinct points in which MILPs are solved in
our ML-powered combinatorial clock auction (ML-CCA):
1. in the training of mMVNNs according to Line 4in Algo-
rithm 1,
2. for Wminimization according to Theorem 3in order to
predict the demand of each agent at a given price vector
(see Line 9in Algorithm 3), and
3. finally to solve the winner determination problem (WDP)
and determine the resulting allocation based on the
elicited bids (see Line 18 in Algorithm 2).
The first two MILPs are of the same type: given as in-
put an mMVNN Mθ
ithat approximates a bidder’s value
function and linear item prices p∈Rm
≥0, find the util-
ity maximizing bundle for that bidder, i.e., solve ˆx∗
i(p)∈
argmaxx∈X Mθ
i(x)− ⟨p, x⟩. The third MILP is of a dif-
ferent type: given as inputs a set of bundle-value tuples
from each agent, find a feasible allocation that maximizes
reported social welfare. This WDP is described in more de-
tail in Section 2and Equation (2). In each clock round, only
two WDP MILPs need to be solved, one involving just the
clock bids of the agents and one also including the bids that
would result from the clock bids raised heuristic. For each
agent, on average two thousand MILPs of type 1 need to be
solved per clock round. It should be noted that they are very
fast, as a single MILP of this type can be solved in under
200 milliseconds in our server architecture as described in
Appendix D.2. The MILPs of the first type used a formula-
tion based on the MILP-formulation for MVNNs in (Weis-
steiner et al. 2023, Section 3.2 and Appednix F) which is
an improved version of the MILP-formulation for MVNNs
in (Weissteiner et al. 2022a, Theorem 2 in Section 3.1 and
Appendix C.5). The MILPs of the first type were solved us-
ing the Gurobi 10 solver, and the WDP MILPs were solved
using CPLEX 20.01.0 . For all MILPs, we set the feasibility
tolerance to 1e−9, the integrality tolerance to 1e−8and the
relative MIP optimality gap to 1e−06. All other parameters
were set to their respective default values.
D.6 Details on NEXT PRICE Procedure
In this section, we describe the details of the NEXT PRICE
procedure from Line 9in Algorithm 2. Given trained
mMVNNs, NE XTPR IC E generates new demand queries by
minimizing Wunder constraint (9b) via GD which is based
on Theorems 2and 3.
20

DOMAIN BIDDER TYP E # HIDDEN LAYER S # HIDDEN UNITS LI N. SKIP LEARNING RATE L 2 REGULARIZATION EPOCHS
GSVM REGIONAL 2 20 FALSE 0.005 0.00001 30
NATIO NAL 3 3 0 TRU E 0.001 0.000001 30
LSVM REGIONAL 1 30 TRUE 0.01 0.000001 30
NATIO NAL 3 2 0 FALS E 0.005 0.0001 30
SRVM L OCAL 2 20 T RUE 0.01 0.0001 30
REGIONAL 1 20 TRUE 0.01 0.0001 50
NATIO NAL 1 3 0 FALS E 0.005 0.00001 70
HIGH FRE QUE NCY 2 20 FALSE 0.01 0.00001 30
MRVM L OCAL 3 20 T RUE 0.005 0.000001 100
REGIONAL 2 20 TRUE 0.001 0.001 100
NATIO NAL 3 2 0 TRU E 0.001 0.0001 50
Table 3: Winning HPO configurations for R2
DOMAIN BIDDER TYP E # HIDDEN LAYER S # HIDDEN UNITS LI N. SKIP LEARNING RATE L 2 REGULARIZATION EPOCHS
GSVM NATION AL 3 10 TRUE 0.001 0.001 30
REGIONAL 2 10 TRUE 0.01 0.001 30
LSVM NATION AL 1 10 TRUE 0.005 0.01 30
REGIONAL 3 20 TRUE 0.005 0.0001 30
SRVM L OCAL 2 30 T RUE 0.01 0.0001 30
REGIONAL 2 20 TRUE 0.01 0.000001 50
NATIO NAL 1 2 0 TRU E 0.01 0.0001 50
HIGH FRE QUE NCY 2 30 TRUE 0.01 0.00001 70
MRVM NATI ONA L 1 20 TRUE 0.001 0.000001 30
REGIONAL 3 20 TRUE 0.001 0.000001 50
LOC AL 2 20 FALSE 0.001 0.000001 30
Table 4: Winning HPO configurations for R2
c
Detailed motivation of constraint (9b) In the case that
linear clearing prices (LCPs) exist, both minimizing Wwith
or without constraint (9b) would lead to clearing prices and
thus to efficient allocations, if the mMVNNs approximate
the value functions vwell enough, as shown in Theorem 2
and Lemma 2, respectively. In this case, constraint (9b) is
neither beneficial nor harmful, because both versions are
well motivated by theory (see Lemma 2and Theorem 2):
In this case the set of solutions to both problems (9) and
(37) are both exactly equal to the set of all possible LCPs
and thus result in efficient allocations with no over-demand
and no under-demand (see the proof of Lemma 2and The-
orem 2in Appendix C.1). Thus in the case that LCPs do
exist, both problems (9) and (37) are exactly equivalent and
well supported by theory. Indeed our experiments resulted in
similarly good results for both versions of the method in do-
mains where LCPs often exist (see GSVM, LSVM, SRVM
in Tables 10 and 11).28
28In Tables 10 and 11 one can see a slight tendency that also for
GSVM, LSVM, SRVM adding constraint (9b) is rather beneficial
on average. The reason for this might be, that we do not always find
LCPs even in these domains (note that LCPs do not always exist in
However, when no LCPs exist, for every price vector p
we have over-demand or under-demand for some goods and
we need to make a choice on how to select a price vector
pfor the next demand query based on the over- and under-
demand.
Minimizing the classical Wintroduced in Lemma 2via a
classical GD-update rule using the gradient derived in Theo-
rem 3punishes over- and under-demand symmetrically. This
can be directly seen from the classical GD-update rule
pnew
j
a.e.
=pj−γ(cj−X
i∈N
(ˆx∗
i(p))j),∀j∈M,
since the magnitude of change in the price vector would be
the same for the same amount of over- or under-demand.
The following example also illustrates this symmetry.
Example D.1. Suppose there is a single item, and two bid-
ders with a value of 5and 5−ϵfor that item. Any price
p∈[5 −ϵ, 5] is a clearing price, where the indirect utility of
the bidder with the higher value is 5−pand of the bidder
with the lower value is 0, while the seller’s indirect revenue
these domains).
21

is pfor a Wvalue of 5. For a price that is x∈R>0higher
than the largest clearing price, i.e., 5 + x, no agent buys the
item and they have an indirect utility of 0, while the seller’s
indirect revenue is 5 + x, for a Wof value 5 + x. For a
price that is xlower than the smallest clearing price, i.e.,
5−ϵ−x, both agents want to buy the item and they have
indirect utilities of ϵ+xand x, while the seller’s indirect
revenue is 5−ϵ−x, for a total Wvalue of 5 + x.
However, even though the Wobjective of Lemma 2pun-
ishes over- and under-demand equally, our preference be-
tween them is highly asymmetric; we strongly prefer under-
demand over over-demand in practice, since the demand re-
sponses of the agents at a price vector with no over-demand
constitute a feasible allocation, while the demand responses
of the agents at a price vector with over-demand do not.
This is important because in case that the market does not
clear within the clock round limit, our ML-CCA, just like
the CCA, will have to combine the clock bids of the agents
to produce a feasible allocation with the highest inferred so-
cial welfare according to Equation (2). If the demand re-
sponses elicited from the agents constituted feasible solu-
tions, it makes it more likely that they can be effectively
combined together in the WDP of Equation (2) to produce
highly efficient allocations. This is why in domains where
no LCPs exist, adding constraint (9b) leads to significantly
increased efficiency (see MRVM in Table 11). For more in-
tuition on constraint (9b) see the following example.
Example D.2. Suppose there are m= 2 items with capaci-
ties c1=c2= 10 and n= 2 bidders with value functions
v1(x) = max 10
1
{x≥(7,3)},10
1
{x≥(3,7)},9
1
{x≥(4,4)},
v2(x) = max 10
1
{x≥(8,2)},10
1
{x≥(2,8)},9
1
{x≥(4,4)}.
In this setting, no LCP exists. This can be seen as follows.
First note that we can obviously exclude every price vector
p∈R2
≥0with p1= 0 or p2= 0 from being a LCP. Fur-
thermore, for any price vector p∈R2
>0bidder 1’s utility
maximizing bundle x∗
1(p)∈ X ∗
1(p) = {(7,3),(3,7),(4,4)}
and bidder 2’s utility maximizing bundle x∗
2(p)∈ X ∗
2(p) =
{(8,2),(2,8),(4,4)}. However, from this we see that x∗
1(p)
and x∗
2(p)cannot be combined without over- or under-
demand, thus violating Item 2in Definition 3.
The clearing potential objective Wis minimized for every
price vector p= (p1, p2)that satisfies p1=p2∈[0,0.5].29
For p1=p2∈(0,0.5), we have X∗
1(p) = {(7,3),(3,7)}
and X∗
2(p) = {(8,2),(2,8)}and thus the there is always
positive over-demand for at least one of the items, which vio-
lates constraint (9b)(this is also the case for p= (0,0)). For
p= (0.5,0.5), we have X∗
1(p) = {(7,3),(3,7),(4,4)}and
X∗
2(p) = {(8,2),(2,8),(4,4)}. Thus, p= (0.5,0.5) ful-
fills constraint (9b), since ((4,4),(4,4)) ∈ X ∗
1(p)× X ∗
2(p)
29The objective function Wcan be formulated as W(p) =
max {0,10 − ⟨(7,3), p⟩,10 − ⟨(3,7), p⟩,9− ⟨(4,4), p⟩)}
+ max {0,10 − ⟨(8,2), p⟩,10 − ⟨(2,8), p⟩,9− ⟨(4,4), p⟩)}
+(10x+ 10y)∀p∈R2
≥0.
The set of minimizers can be seen by plotting W.
is feasible (see Footnote 3). Thus, p= (0.5,0.5) is the
unique solution of the constrained problem (9). In this case,
((4,4),(4,4)) would be the efficient allocation with a SCW
of 18. If we had only asked demand queries for prices
p1=p2∈[0,0.5), i.e., prices that solve the unconstrained
minimization problem (37), but not the constrained mini-
mization problem (9), the WDP would end up with a SCW
of only 10 by allocating some bundle of value 10 to one
of the bidders and nothing to the other bidder, since the
WDP is constrained by feasibility due to the limited capacity
c= (10,10).
Details on NEXT PRICE (Algorithm 3)In Algorithm 3,
we present the details of our NEXT PRICE procedure, a mod-
ification of the classical GD in Theorem 3that systemat-
ically favours under-demand over over-demand (see Sec-
tion 4). Compared to classical gradient descent on W(based
on Theorem 3), there are three noteworthy modifications in
the NE XTPRICE procedure.
1. First, as outlined at the end of Section 4, to incentivize
GD on W(p, (Mθ
i)n
i=1)towards price vectors with no
positive over-demand, the GD steps punish over- and
under-demand asymmetrically. Specifically, at each iter-
ation step, in case of predicted over-demand for some
good, the gradient step for that good is (1 + µ)-times
larger than what it would have been in case of under-
demand (Line 26). Finally, µis not a constant, but it adap-
tively increases as long as Algorithm 3has not found a
price vector with no predicted over-demand (Line 29).
2. Second, as also outlined at the end of Section 4, once the
gradient steps have terminated, Algorithm 3returns the
price vector pthat led to the lowest value of Wamong all
price vectors examined that led to no positive predicted
over-demand (i.e., satisfying constraint (9b)) (Lines 16
to 18).30
3. Finally, the learning rate for each good in Algorithm 3is
scaled to be proportional to that good’s current price pj
(Line 23). In theory, we do not have to do this, as The-
orem 3guarantees that even a uniform learning rate for
all goods cannot get stuck in local minima of W. Using
a uniform learning rate for all goods has two disadvan-
tages. First, we would have to tune that learning rate pa-
rameter separately for each domain, since the goods’ val-
ues are in different scales in each domain. Additionally,
in the SRVM and MRVM domains the prices of differ-
ent goods can vary by orders of magnitude. If we were
to select a uniform learning rate for all goods, we would
have to select one that would be suitable for the lowest-
valued items (otherwise the GD steps would overshoot a
lot for the prices of lower-valued goods, i.e. GD, would
jump back and forth between large amounts of over- and
under- demand for lower-valued goods), which would in-
crease significantly the number of steps required until the
learning rate becomes sufficiently small so that we do
30If every gradient step resulted in positive predicted over-
demand, we would pick just the one with minimal Wignoring the
constraint (9b) for this demand query (Lines 30 to 31), but this case
never occurred in our experiments (see Figure 3).
22

Algorithm 3: NEX TPRICE
Input : Trained MVNNs Mθ
in
i=1, last Finit round prices
pQinit , Epochs T∈N, Learning Rate Base λ > 0,
Learning Rate Decay η∈[0,1], Feasibility
multiplier µ, Feasibility multiplier increment ν
1for j= 1 to mdo
2p0
j←∼ U[0.75 ·pQinit
j,1.25 ·pQinit
j]
3Wbest ← ∞
4Wf
best ← ∞
5feasible ←False
6for t= 0 to T−1do
7W←pt, c▷Seller’s indirect revenue
8for i= 1 to ndo
9Solve ˆx∗
i(pt)∈argmaxx∈X Mθ
i(x)−pt, x
10 Ui← Mθ
i(ˆx∗
i(pt)) −pt,ˆx∗
i(pt)▷Bidder i’s
indirect Utility
11 W←W+Ui
12 d←Pi∈Nˆx∗
i(pt)▷Total Predicted Demand
13 if W < Wbest then ▷Found better prices wrt. W
14 Wbest ←W
15 pbest ←pt
16 if W < W f
best and d≤cthen ▷Found better
feasible prices
17 Wf
best ←W
18 pf
best ←pt
19 feasible ←True
20 if d=cthen ▷Predicted Market Clearing Prices
21 break
22 for j= 1 to mdo
23 γj←λ·pt
j▷Scale l.r. for each good
24 pt+1
j←pt
j−γj(cj−dj)▷Theorem 3,
eq. (11a)
25 if dj> cjthen ▷Over-demand for good j
26 pt+1
j←pt
j−µγj(cj−dj)▷Equation (11)
27 λ←λ·(1 −η)▷Learning rate decay
28 if not feasible then ▷No feasible allocation yet
29 µ←µ·ν
30 if not feasible then ▷No feasible allocation found
31 pf
best ←pbest ▷Footnote 30
32 if µ=ν= 0 then ▷Do not enforce feasibility (see
Remark D.3)
33 return Prices pbest minimizing W(·,(Mθ
i)n
i=1)
34 return Feasible prices pf
best minimizing W(·,(Mθ
i)n
i=1)
not have such extreme jumps. Scaling the learning rate
for each good proportionally to its current price allevi-
ates both of these potential issues.
Remark D.3. Note that by setting µ=ν= 0,NE XTPRIC E
(Algorithm 3) performs symmetrical GD on Wwithout con-
straint (9b)as suggested by Theorem 3(see Appendix D.9
for an empirical evaluation of minimizing Wwith µ=ν=
0, i.e., without constraint (9b)).
Remark D.4. For each GD-step we solve the in-
ner optimization problem of Equation (7), i.e.,
max
x∈X Mθ
i(x)− ⟨p, x⟩, in Line 9for each bidder i,
using the MILP encoding of MVNNs from (Weissteiner et al.
2022a).31
In our experiments, we use 300 epochs for all domains,
with a good-specific learning rate of 1% of the price pt
jof
that good and a learning rate decay of 0.5%, i.e., we set T=
300, λ = 0.01 and η= 0.005, while we set µ= 2 and
ν= 1.01.
Intuitively, this way Algorithm 3punishes over-demand
at least three times as much as under-demand, which means
that it can very quickly converge to a price region with no
over-demand, and then it starts minimizing under-demand
in the same way as suggested by Theorem 3. Setting νto a
number even slightly larger than 1ensures that Algorithm 3
can converge to such a price region even in the extreme
case where it starts with large amounts of over-demand.
As shown in Figure 3, even in the MRVM domain where
no linear clearing prices exist, the modifications of Algo-
rithm 3were sufficient for it to return a price vector with no
predicted over-demand in all ML-powered clock rounds, in
100% of our instances (i.e., SATS seeds), while this num-
ber was almost 0% if we were to apply symmetrical GD as
suggested by Theorem 3by setting µ=ν= 0 in our Algo-
rithm 3. Those results can be found in Appendix D.9.
Figure 3: Fraction of instances in the MRVM domain where
the price vector returned by Algorithm 3was predicted to
be feasible per iteration (starting after the Qinit-phase, i.e., in
clock round 50). This fraction is constantly 100% across all
rounds.
The following Example D.3 shows that even in cases
where the constraint (9b) is mathematically irrelevant, the
asymmetry of Algorithm 3can still be very beneficial.
Example D.3. Let there be m= 1 item with capacity c=
10 and n= 2 bidders with value functions v1(x)=6
1
{x≥6}
and v2(x)=3
1
{x≥1}+2
1
{x≥5}.32 First, note that similarly
as in Example D.2 in this example also no LCP exists. For
31The actual MILP encoding we are using is based on the im-
proved MILP-encoding of Weissteiner et al. (2023, Section 3.2 and
Appendix F) and slightly modified to work with mMVNNs instead
of classical MVNNs.
32In the case of m= 1, we do not distinguish between the 1-
dimensional vector xand the number x1(just as we write p=p1
and c=c1).
23

every p < 0.5we have an over-demand of 1, and for ev-
ery p > 0.5we have an under-demand of at least 3(3for
p∈(0.5,1],9for p∈[1,3] or 10 for p≥3). For p= 0.5,
we have X∗
1(0.5) = {6}and X∗
2(0.5) = {1,5}and thus
the over-demand is either 1or −3. Thus, the price p= 0.5
is the unique minimizer of Wand p= 0.5also fulfills con-
straint (9b)(see Footnote 3). Therefore, p= 0.5is both the
unique solution to the constraint problem (9) and the unique
solution to the unconstrained problem (37), which makes
the two optimization problems (9)and (37)mathematically
equivalent in this case.
However in practice, any GD-based algorithm will almost
never be able to exactly compute p= 0.5. If we run the sym-
metric version of Algorithm 3(see Remark D.3) we would
either end up with a price pslightly below 0.5or slightly
above.33 However, our asymmetric Algorithm 3makes sure
that we do not end up with a price pbelow 0.5, which would
result in over-demand, but rather at a price pslightly above
0.5, which results at the feasible allocation where the first
bidder gets 6items and the second bidder gets 1item. In this
case, this would be the efficient allocation with a SCW of 9.
If we had only asked demand queries for prices p∈(0,0.5)
then the WDP would end up with a SCW of only 6by al-
locating 6items to first bidder and 0items to the second
bidder, since the first bidder would answer any of these de-
mand queries with 6items and the second bidder would an-
swer them all with 5items, which cannot be combined by the
WDP for a capacity of c= 10 <11.
D.7 Detailed Experimental Results
Detailed Efficiency Results In Tables 5and 6, we pro-
vide the detailed efficiency results corresponding to Table 1
including 95%-bootstrapped CIs and p-values. Concretely,
we now present triplets which show the lower bound of the
bootstrapped 95%-CI, the mean, and the upper bound of the
bootstrapped 95%-CI (e.g., (97.05 , 97.87 , 98.56) means
that the lower bound of the bootstrapped 95%-CI is equal
to 97.05, the mean is equal to 97.87, and the upper bound
of the bootstrapped 95%-CI is equal to 98.56). Those boot-
strapped CIs were created with the percentile method and
10.000 bootstrap-samples. It is noteworthy that in all do-
mains other than SRVM (which is very easy, and can be
solved by both mechanisms), our ML-CCA outperforms the
CCA, both for the clock bids and the clock bids raised, and
we can reject the null hypothesis of ML-CCA not outper-
forming the CCA in terms of efficiency at great confidence
levels that, based on the domain, vary from less than 2% all
the way to less than 7·10−18%= 7e−20.
33In this case we would even end up more likely with a price
below 0.5, because than we only have an over-demand of 1rather
than an under-demand of 3items. In every step, where ptis slightly
below 0.5, GD will push up the price by only 1γ, while in the steps
where ptis slightly above 0.5, GD will push down the price by 3γ.
The probability of exactly reaching p= 0.5is zero if we initialize
p0with a continuous distribution (as we do in Line 2). Also Line 31
is more likely to pick a price slightly below 0.5, since for every
ϵ∈[0,0.5),W(0.5+ϵ, v) = W(0.5, v)+3ϵand W(0.5−ϵ, v) =
W(0.5, v)+1ϵ(see Theorem 3). I.e., Line 31 would clearly prefer
p= 0.5−ϵover p= 0.5 + ϵ.
For GSVM and LSVM, for both practical bidding heuris-
tics (clock bids and clock bids raised) the improvement of
our ML-CCA over the CCA is highly significant with all p-
values being below 2e−14. For SRVM, the differences be-
tween the methods seem to be small, since both methods al-
most reach 100% efficiency. However, for clock bids raised
this improvement is clearly statistically significant with a p-
value of 0.0021%, while for clock bids there is actually no
statistically significant difference. Note that for 7 out of all
8 practical settings (4 domains with two practical bidding
heuristics) the p-value is below 1%. For clock bids raised all
four domains have a p-value below 0.0021%. For MRVM,
for all three bidding heuristics our ML-CCA is significantly
better than the CCA with p-values 0.71%, 1.6e−5and 3e−4.
In all three domains where LCPs exist, our ML-CCA
found them statistically significantly more often than the
CCA with p-values 3.2e−18,2.6e−8and 1.22%.
When reading the efficiency results in Tables 5and 6one
should keep in mind that the CCA has generated over $20
Billion in revenue for spectrum allocations between 2012
and 2014 alone (Ausubel and Baranov 2017). Since rev-
enue is a lower bound for SCW, improving CCA’s efficiency
on average by 1% point would have improved the SCW by
more than $200 Million within this time range alone and
CCA is still the most prominent practical mechanism for
spectrum allocation.
Instead of efficiency V(a)
V(a∗), one could also study the effi-
ciency loss V(a∗)−V(a)
V(a∗)= 1 −V(a)
V(a∗), which corresponds to
the relative cost of deviating from the efficient allocation in
terms of social welfare. For GSVM with clock bids only our
ML-CCA can cut down the efficiency loss of the CCA by a
factor 5.4from 9.6% to 1.77%. Similarly for GSVM with
clock bids raised our method can cut down the efficiency
loss by a factor 5.9from 6.41% to 1.07%.
Path Plots of Profit-Max Bids In Figure 4, we show the
effect of adding up to QP-Max = 100 bids in the supplemen-
tary round of both our ML-CCA mechanism as well as the
CCA using the profit-max heuristic. In GSVM, both mech-
anisms can reach 100% efficiency using those profit-max
bids. However, ML-CCA’s clock phase can do so after only
18 profit-max bids, while the CCA requires 44. In LSVM,
for any number of profit max bids, our mechanism exhibits
higher efficiency than the CCA, while with 100 profit-max
bids we can reach 99.95% efficiency as opposed to 99.76%
for the CCA. In SRVM, both mechanisms can reach over
99.99% efficiency using only 4profit max bids. In MRVM,
we can see that for almost any number of profit-max bids,
our ML-CCA outperforms the CCA and the results are sta-
tistically significant on the 95% CI level.34 Furthermore, for
34Note that for example for 100 profit-max bids, the 95% CIs
slightly overlap, while the corresponding p-value of the paired test
is 0.03%= 3e−4. This suggest that a paired test would show the
statistical significance of our ML-CCA having a higher average ef-
ficiency than the CCA for probably any number of profit-max bids.
Note that a paired test is the correct statistical test for such situ-
ations, since both ML-CCA and the CCA were evaluated on the
same 100 SATS-seeds.
24

GSVM LSVM
MECHANISM ECLOCK ERAIS E EPROFIT CLE AR ECLOCK ERAI SE EPROFIT CL EAR
ML-CCA (97.38 , 98.23 , 98.91) (98.51 , 98.93 , 99.30) (100.00 , 100.00 , 100.00) 56 (89.78 , 91.64 , 93.34) (95.56,96.39,97.16) (99.90 , 99.95 , 99.99) 26
CCA (88.89 , 90.40 , 91.84) (92.64 , 93.59 , 94.49) (99.99 , 100.00 , 100.00) 3 (80.94 , 82.56 , 84.11) (90.64 , 91.60 , 92.54) (99.55 , 99.76 , 99.91) 0
p-VALUE 4.2E-18 6.5E-20 0.14 3.19E-18 1.8E-17 1.6E-14 0.0101 2.57E-8
Table 5: Detailed results for the GSVM and LSVM domains of ML-CCA vs CCA including the lower and upper 95%-
bootstrapped CI bounds over a test set of 100 instances of the following metrics: ECLOCK = efficiency in % for clock bids,
ERAISE = efficiency in % for raised clock bids, EPROFI T = efficiency in % for raised clock bids and 100 profit-max demand
queries, CLE AR = percentage of instances where linear clearing prices were found in the clock phase. Winners based on a
paired t-test with α= 5% are marked in grey. The p-value for this pairwise t-test with H0:µML-CCA ≤µCCA shows at which
significance level we can reject the null hypothesis of CCA having a higher or equal average value in the corresponding metric
than ML-CCA.
SRVM M RVM
MECHANISM ECLOCK ERAIS E EPROFIT CLE AR ECLOCK ERAI SE EPROFIT CL EAR
ML-CCA (99.48 , 99.59 , 99.68) (99.92 , 99.93 , 99.95) (100.00 , 100.00 , 100.00) 13 (92.79 , 93.04 , 93.28) (93.09 , 93.31 , 93.52) (93.46 , 93.68 , 93.89) 0
CCA (99.52 , 99.63 , 99.73) (99.75 , 99.81 , 99.86) (100.00 , 100.00 , 100.00) 8 (91.87 , 92.44 , 92.86) (92.25 , 92.62 , 92.96) (92.84 , 93.18 , 93.48) 0
p-VALUE 0.78 2.1E-5 - 0.0122 7.1E-3 1.6E-5 3.0E-4 -
Table 6: Detailed results for the SRVM and MRVM domains of ML-CCA vs CCA including the lower and upper 95%-
bootstrapped CI bounds over a test set of 100 instances of the following metrics: ECLOCK = efficiency in % for clock bids,
ERAISE = efficiency in % for raised clock bids, EPROFI T = efficiency in % for raised clock bids and 100 profit-max demand
queries, CLE AR = percentage of instances where linear clearing prices were found in the clock phase. Winners based on a
paired t-test with α= 5% are marked in grey. The p-value for this pairwise t-test with H0:µML-CCA ≤µCCA shows at which
significance level we can reject the null hypothesis of CCA having a higher or equal average value for the corresponding metric
than ML-CCA.
94
96
98
100
Efficiency in %
GSVM
ML-CCA profit-max
CCA profit-max
92.5
95.0
97.5
100.0
LSVM
1 20 40 60 80 100
Number of Profit Max Queries
99.8
99.9
100.0
Efficiency in %
SRVM
1 20 40 60 80 100
Number of Profit Max Queries
92.5
93.0
93.5
MRVM
Figure 4: Efficiency of adding additionally QP-Max = 100
profit-max bids in SATS for ML-CCA and CCA after 100
clock bids and 100 raised clock bids. Averaged over 100 runs
including a bootstrapped 95% CI.
MRVM, it is interesting to note that the CCA, even with 100
profit max bids per agent, cannot reach the clock bids raised
efficiency of our ML-CCA (i.e., the efficiency with 0profit
max bids), while it needs 38 profit max bids to reach the ef-
ficiency that the clock phase of our ML-CCA achieves. In
other words, the CCA requires up to an additional 138 value
bids per agent to achieve the same efficiency that our ML-
CCA can achieve using only 100 clock bids.
Path Plots of Clearing Error and Linear Item Prices In
Figures 5to 8, we present for all domains in SATS the path
Figure 5: Left: CE of ML-CCA and CCA in GSVM per it-
eration (starting after the Qinit-phase, i.e., in clock round 20)
averaged over 100 runs including the standard error. Right:
linear item prices pr
j∈R≥0for j= 1,...,18 defining the
demand query for each clock round r= 0,...,100 averaged
over 100 runs.
plots for clock rounds r= 0,...,100 of the (squared) clear-
ing error (CE) defined as:
m
X
j=1 
 n
X
i=1
x∗
i(pr)j−cj!2
,(84)
and the linear item prices pr
j∈R≥0for j= 1, . . . , m.
In Figure 5, we present the results for GSVM. We observe
that, for any iteration after the initial Qinit = 20 clock rounds,
i.e., any clock round r= 20,...,100, the CE of our ML-
CCA is smaller than the CE resulting from CCA. Specifi-
cally, ML-CCA has already at iteration 0 (clock round 20)
a small CE (≈7) whilst CCA needs approximately 20 more
iterations to reach a similar CE.
25

Figure 6: Left: CE of ML-CCA and CCA in LSVM per it-
eration (starting after the Qinit-phase, i.e., in clock round 20)
averaged over 100 runs including the standard error. Right:
linear item prices pr
j∈R≥0for j= 1,...,18 defining the
demand query for each clock round r= 0,...,100 averaged
over 100 runs.
Moreover, from the path plots of the prices we can dis-
tinguish the two phases of our proposed ML-CCA: the ini-
tial CCA phase with a predefined fixed price increment in
case of over-demand for the first 20 clock rounds (or 50 in
the case of MRVM), and the ML-powered demand query
generation phase starting with the 21th (or 51th for MRVM)
clock round. We observe that our approach, for the price of
each item, is immediately searching in a local neighbour-
hood around the plateaued CCA price of that item, and tries
to clear the market by slightly increasing and decreasing cer-
tain prices. Finally, we can see that CCA properly plateaus
to final CCA prices around clock rounds 80 −100, where no
item is over-demanded anymore.
In Figure 6, we present the results for LSVM. We can see
that for any iteration after the initial Qinit = 20 clock rounds,
i.e., any clock round r= 20,...,100, the CE of our ML-
CCA is significantly smaller than the CE of CCA. Specifi-
cally, CCA requires 55 iterations (i.e., 75 clock rounds) to
reach a CE comparable to what ML-CCA can achieve in the
first iterations.35 The price path plots in LSVM display a
similar picture as in GSVM. We see that ML-CCA immedi-
ately identifies the correct region after the Qinit = 20 initial
CCA prices and then tries to locally search by increasing and
decreasing prices around the plateaued CCA prices, without
at the same time sacrificing efficiency, as would be the case
if we were to increase the price increment of CCA to reach
that price area faster.
In Figure 7, we present the results for SRVM on a log
scale. We can see again that, for any iteration after the ini-
tial Qinit = 20 clock rounds, i.e., any clock round r=
20,...,100, the CE of our ML-CCA is smaller than that
of CCA. Furthermore, we can see that in less than 20 itera-
tions, our ML-CCA is able to drop the CE down to 1.1(with
1being a lower bound on the CE when clearing prices do
not exist), while the CCA can never reach those numbers.
Recall, that in SRVM there are only three distinct items
(i.e., m= 3) with quantities c1= 6, c2= 14, and c3= 9.
35Note that by increasing the price increment for CCA, one
could reduce the number of iterations until it achieves a low CE,
but that could result in a significant drop in the efficiency of the
auction, see Appendix D.8.
Figure 7: Left: CE of ML-CCA and CCA in SRVM per it-
eration (starting after the Qinit-phase, i.e., in clock round 20)
averaged over 100 runs including the standard error. Right:
linear item prices pr
j∈R≥0for j= 1,...,3defining the
demand query for each clock round r= 0,...,100 averaged
over 100 runs. Both y-axes are on a log scale.
We again see the same behaviour of ML-CCA’s price dis-
covery mechanism as in the other SATS domains: ML-CCA
is able to immediately identify prices for the three items that
are close to the final plateaued CCA prices.
In Figure 8, we present the results for MRVM. Interest-
ingly, in this domain the CCA reaches a lower CE than our
ML-CCA. However, please note that CE, as defined in Equa-
tion (84), penalizes all goods equally, which can be an un-
informative metric in domains where the values of differ-
ent goods vary significantly. This is most pronounced in the
MRVM domain, where the prices of the most valuable items
are more than 100 times larger than the prices of the least
valuable goods , as shown in the right part Figure 8.
Figure 8: Left: CE of ML-CCA and CCA in MRVM per it-
eration (starting after the Qinit-phase, i.e., in clock round 50)
averaged over 100 runs including the standard error. Right:
linear item prices pr
j∈R≥0for j= 1,...,42 defining the
demand query for each clock round r= 0,...,100 averaged
over 100 runs.
Compute Time In Table 7we report, for our choice of hy-
perparameters given in Table 3, the average time per round
required in each domain to train the NmMVNNs of the bid-
ders according to our Algorithm 1and the time required to
generate the next price vector, given the trained MVNNs,
using our Algorithm 3. The sum of those two numbers is
the average time per round required by our ML-CCA per
domain to generate the next demand query, once the bid-
ders have responded to the current one. For this experiment,
we report average results over the same 100 instances as all
other experiments in this paper.
26

Domain Train Time Price Gen. Time Total
GSVM 4.49 1.81 6.30
LSVM 2.60 1.19 3.79
SRVM 1.26 0.41 1.67
MRVM 32.22 11.19 43.41
Table 7: Detailed results of the average time required (in
minutes) for ML-CCA per round to train the mMVNNs of
all bidders, and to generate the price vector of the next de-
mand query, given the trained mMVNNs. Shown are average
results over 100 instances.
D.8 Experimental Results for Reduced Qmax = 50
In this section, we present all results of ML-CCA36 and CCA
for a reduced number of Qmax = 50 demand queries instead
of Qmax = 100, which were presented in the main paper in
Section 6. For ease of exposition we also include the CCA
optimized for Qmax = 100 as in Section 6. We additionally
present 95% CIs and a paired t-test with α= 5%. The p-
value for this pairwise t-test with H0:µML-CCA ≤µCCA
shows at which significance level we can reject the null hy-
pothesis of CCA with Qmax = 50 having a higher or equal
average value in the corresponding metric than the ML-CCA
with Qmax = 50. All results are presented in Tables 8and 9.
Just like for Qmax = 100, our ML-CCA outperforms
the CCA considerably in all domains. Specifically, the ef-
ficiency improvement after the clock phase is over 7.3%
points for GSVM, 8.6% points in LSVM and 3.4% points
in MRVM, and all of those improvements are highly statisti-
cally significant, based on a paired t-test with α= 2.4e−10.
The two mechanisms are statistically tied in SRVM (other
than for raised clock bids, where our ML-CCA again out
performs the CCA). As pointed out in Section 6, this domain
is very easy, and both mechanisms can solve it even with
50 clock rounds). If we add the clock bids raised heuristic
of the supplementary round to both mechanisms, the effi-
ciency improvement of ML-CCA is 4.9% points in GSVM,
4.4% points in LSVM and 3.1% points in MRVM. Again all
those improvements are highly significant with α= 2.9e−7,
this time also for SRVM and thus for all fur domains. Fi-
nally, it is noteworthy that in the GSVM and LSVM do-
mains, our ML-CCA with 50 clock rounds can achieve sig-
nificantly higher efficiency with 50 clock rounds compared
to the CCA with 100. These results even persist if we add
the clock bids raised heuristic of the supplementary round to
both mechanisms, which would induce up to an additional
100 value queries for each bidder in the CCA, and only 50
value queries for our ML-CCA.
D.9 Experimental Results for unconstrained W
minimization
In this section, we empirically evaluate the importance of
constraint (9b) in the NEXT PRICE-procedure by comparing
36For ML-CCA, we used the same HPs for all domains as in
Section 6, other than MRVM, were we also set Qinit = 20.
the efficiency results of ML-CCA with constraint (9b) (ML-
CCA-C) and without it (ML-CCA-U).
Constraint (9b) ensures that the predicted induced de-
mand should constitute a feasible allocation for every clock
round of ML-CCA-C, as discussed in Section 4and Ap-
pendix D.6.37 On the other side, ML-CCA-U optimizes W
without any constraint (i.e., by performing unconstrained
classical GD on Was suggested by Lemma 2and Theo-
rem 3).38
Those results are presented in Tables 10 and 11. In the
GSVM, LSVM and SRVM domains, the results for the two
approaches are almost identical (while constrained Wmini-
mization is statistically better in a few cases). A noteworthy
difference is that for the GSVM and LSVM domains, the
unconstrained Wminimization clears the market in 5% and
3% less of the cases compared to the constrained version.
Overall, as suggested in Section 4and Appendix D.6, in do-
mains where linear prices can achieve low clearing error (see
Appendix D.7, Figures 5to 7) minimizing Wby performing
classical GD on it without any additional constraints suf-
fices for significant efficiency improvements compared to
the CCA.
In the MRVM39 domain however, we can see that the ef-
ficiency improvement of performing constrained Wmini-
mization compared to the unconstrained one is highly statis-
tically significant across all three bidding heuristics with p-
values ranging from 1.0e−8to 9.3e−6. Without push bids,
the efficiency improvement is approximately 1% point. This
efficiency improvement also persists if we add the clock bids
raised and profit max heuristics for the supplementary round,
and is again highly statistically significant. Thus, we can
conclude that in all cases, there is no disadvantage to using
the constrained Wminimization to generate the next price
vector in ML-CCA. This clear improvements of ML-CCA-C
over ML-CCA-U fits well our hypothesis stated in Remark 1
that constraint (9b) is especially important in cases where no
LCPs exist (or when the market exhibits a high clearing error
as defined in Equation (84), see Figures 5to 8).
D.10 Experimental Results for using MVNNs on
multiset domains
In this section, we experimentally evaluate the benefits of
mMVNNs over MVNNs for multiset domains by compar-
ing the efficiency results of ML-CCA with mMVNNs (ML-
CCA-mMVNN) and MVNNs (ML-CCA-MVNN) as the
neural network architecture. We only compare the two ar-
chitectures for the two multiset domains, i.e., SRVM and
MRVM, as in the other two domains, the two architectures
are mathematically equivalent. It is important to note that,
37ML-CCA-C is our default method, which we simply call ML-
CCA outside of Appendix D.9. In particular, we used NEXTPRICE
(Algorithm 3) with default hyper-parameters as discussed in Ap-
pendix D.6.
38For ML-CCA-U we ignore constraint (9b), which corresponds
to setting the hyper-parameters µ=ν= 0 in Algorithm 3as
described in Remark D.3.
39For this test in MRVM, we used Qinit = 70 for both ML-CCA-
C and ML-CCA-U.
27

GSVM LSVM
MECHANISM ECLOCK ERAIS E EPROFIT CLE AR ECLOCK ERAIS E EPROFIT CLE AR
ML-CCA (QMAX = 50)(96.97 , 97.84 , 98.58) (98.10 , 98.59 , 99.03) (100.00 , 100.00 , 100.00) 51 (88.99 , 90.81 , 92.50) (95.07 , 95.91 , 96.70) (99.90 , 99.95 , 99.99) 17
CCA (QMAX = 50) (89.05 , 90.51 , 91.88) (92.74 , 93.70 , 94.62) (99.99 , 100.00 , 100.00) 1 (80.57 , 82.21 , 83.77) (90.59 , 91.52 , 92.46) (99.64 , 99.80 , 99.93) 0
CCA (QMAX = 100) (88.89 , 90.40 , 91.84) (92.64 , 93.59 , 94.49) (99.99 , 100.00 , 100.00) 3 (80.94 , 82.56 , 84.11) (90.64 , 91.60 , 92.54) (99.55 , 99.76 , 99.91) 0
p-VALUE (QMAX = 50) 4 .2E-17 4.2E-18 0.1433 7.0E-17 2.5E-16 3.1 E-13 0.0145 9.1E-6
Table 8: Detailed results for the GSVM and LSVM domains of ML-CCA vs CCA for Qmax = 50 including the lower and
upper 95%-bootstrapped CI bounds over a test set of 100 instances of the following metrics: ECLOCK = efficiency in % for clock
bids, ERAI SE = efficiency in % for raised clock bids, EPRO FIT = efficiency in % for raised clock bids and 100 profit-max demand
queries, CLE AR = percentage of instances where clearing prices were found in the clock phase. Winners for Qmax = 50 based
on a paired t-test with α= 5% are marked in grey. The p-value for this pairwise t-test with H0:µML-CCA ≤µCCA shows at
which significance level we can reject the null hypothesis of CCA with Qmax = 50 having a higher or equal average value in the
corresponding metric than ML-CCA with Qmax = 50. Additionally, we also reprint the CCA (Qmax = 100) results from Table 5
without marking statistical significance.
SRVM M RVM
MECHANISM ECLOCK ERAISE EPROFIT CL EAR ECLOCK ERAISE EPRO FIT CLEA R
ML-CCA (QMAX = 50)(99.47 , 99.58 , 99.67) (99.92 , 99.93 , 99.95) (100.00 , 100.00 , 100.00) 13 (91.63 , 92.11 , 92.50) (91.94 , 92.42 , 92.81) (92.73 , 93.04 , 93.34) 0
CCA (QMAX = 50) (99.36 , 99.47 , 99.59) (99.64 , 99.72 , 99.79) (100.00 , 100.00 , 100.00) 4 (87.70 , 88.70 , 89.61) (88.52 , 89.28 , 90.02) (89.57 , 90.27 , 90.92) 0
CCA (QMAX = 100) (99.52 , 99.63 , 99.73) (99.75 , 99.81 , 99.86) (100.00 , 100.00 , 100.00) 8 (91.87 , 92.44 , 92.86) (92.25 , 92.62 , 92.96) (92.84 , 93.18 , 93.48) 0
p-VALUE (QMAX = 50) 0.088 2.9E-7 - 0.0011 2.4E-10 1.3E-12 1.6E-14 -
Table 9: Detailed results for the SRVM and MRVM domains of ML-CCA vs CCA for Qmax = 50 including the lower and
upper 95%-bootstrapped CI bounds over a test set of 100 instances of the following metrics: ECLOCK = efficiency in % for clock
bids, ERAI SE = efficiency in % for raised clock bids, EPRO FIT = efficiency in % for raised clock bids and 100 profit-max demand
queries, CLE AR = percentage of instances where clearing prices were found in the clock phase. Winners for Qmax = 50 based
on a paired t-test with α= 5% are marked in grey. The p-value for this pairwise t-test with H0:µML-CCA ≤µCCA shows
at which significance level we can reject the null hypothesis of CCA with Qmax = 50 having a higher or equal average value
in the corresponding metric than ML-CCA with Qmax = 50. In all domains (including MRVM) we used Qinit = 20 for this
experiment. Additionally, we also reprint the CCA (Qmax = 100) results from Table 6without marking statistical significance.
in the case of MVNNs, even though the network has not in-
corporated the prior knowledge that some items are identi-
cal copies of each other, the price generation algorithm does
make use of that prior information: in the case of MVNNs,
our price generation algorithm appropriately calculates the
total demand of each item as the aggregate demand of that
item’s copies, and then sets the same price for all of those
copies.
Those results are presented in Table 12. In the SRVM do-
main, the performance of the two architectures is almost
identical in terms of both clearing potential and efficiency.
The only statistically significant result is that mMVNNs
slightly outperform MVNNs in terms of efficiency if the
raised clock bids heuristic is used in the supplementary
round. In the MRVM domain, (linear) clearing prices never
exist, so no architecture ever clears the market. In terms
of efficiency, the only statistically significant result in this
domain is that MVNNs actually achieve 0.06% higher ef-
ficiency compared to mMVNNs after the clock phase. We
have good reason to believe that the strong performance of
MVNNs is because, as explained in the previous paragraph,
the price generation algorithm does make use of the fact that
some items are identical copies of each other, even though
the MVNNs do not make use of that information. How-
ever, we are currently unable to verify this hypothesis, as the
SATS simulator only supports demand queries where copies
of the same item have identical prices.
28

GSVM LSVM
MECHANISM ECLOCK ERAIS E EPROFIT CLE AR ECLOCK ERAI SE EPROFIT CL EAR
ML-CCA-C (97.38 , 98.23 , 98.91) (98.51 , 98.93 , 99.30) (100.00 , 100.00 , 100.00) 56 (89.78 , 91.64 , 93.34) (95.56 , 96.39 , 97.16) (99.90 , 99.95 , 99.99) 26
ML-CCA-U (97.05 , 97.87 , 98.56) (98.22 , 98.67 , 99.07) (100.00 , 100.00 , 100.00) 51 (89.84 , 91.60 , 93.28) (95.33 , 96.16 , 96.94) (99.90 , 99.95 , 99.99) 23
p-VALUE 0.0414 0.0965 - 0.0122 0.3428 0.0189 - 0.0416
Table 10: ML-CCA with constrained W(ML-CCA-C) and unconstrained Wminimization (ML-CCA-U). Shown are averages
including the lower and upper 95%-bootstrapped CI bounds over a test set of 100 synthetic CA instances for the GSVM and
LSVM domains of the following metrics: efficiency in % for clock bids (ECLOCK), raised clock bids (ERA IS E ) and raised clock
bids and 100 profit-max bids (EPR OFI T ) and percentage of instances where linear clearing prices were found (CLEAR). Winners
based on a paired t-test with α= 5% are marked in grey. The p-value for this pairwise t-test with H0:µML-CCA-C ≤µML-CCA-U
shows at which significance level we can reject the null hypothesis of ML-CCA-U having a higher or equal average value in
the corresponding metric than ML-CCA-C.
SRVM M RVM
MECHANISM ECLOCK ERAIS E EPROFIT CLE AR ECLOCK ERAI SE EPROFIT CL EAR
ML-CCA-C (99.48 , 99.59 , 99.68) (99.92 , 99.93 , 99.95) (100.00 , 100.00 , 100.00) 13 (92.90 , 93.12 , 93.34) (93.03 , 93.25 , 93.47) (93.46 , 93.67 , 93.88) 0
ML-CCA-U (99.54 , 99.63 , 99.70) (99.91 , 99.93 , 99.94) (100.00 , 100.00 , 100.00) 13 (91.49 , 92.06 , 92.55) (91.88 , 92.31 , 92.70) (92.27 , 92.70 , 93.09) 0
p-VALUE 0.7793 0.0431 - - 9.3E-6 2.7E-08 1.0E-8 -
Table 11: ML-CCA with constrained W(ML-CCA-C) and unconstrained Wminimization (ML-CCA-U). Shown are averages
including the lower and upper 95%-bootstrapped CI bounds over a test set of 100 synthetic CA instances for the SRVM and
MRVM domains of the following metrics: efficiency in % for clock bids (ECLOCK), raised clock bids (ERA IS E ) and raised clock
bids plus 100 profit-max bids (EPR OFI T ) and percentage of instances where linear clearing prices were found (CLEAR). Winners
based on a paired t-test with α= 5% are marked in grey. The p-value for this pairwise t-test with H0:µML-CCA-C ≤µML-CCA-U
shows at which significance level we can reject the null hypothesis of ML-CCA-U having a higher or equal average value in
the corresponding metric than ML-CCA-C.
SRVM M RVM
MECHANISM ECLOCK ERAISE EPROFIT CL EAR ECLOCK ERAISE EPRO FIT CLEA R
ML-CCA-MMVNN (99.48 , 99.59 , 99.68) (99.92 , 99.93 , 99.95) (100.00 , 100.00 , 100.00) 13 (92.90 , 93.12 , 93.34) (93.03 , 93.25 , 93.47) (93.46 , 93.67 , 93.88) 0
ML-CCA-MVNN (99.53 , 99.63 , 99.71) (99.89 , 99.91 , 99.93) (100.00 , 100.00 , 100.00) 13 (92.98 , 93.18 , 93.37) (93.19 , 93.39 , 93.57) (93.48 , 93.69 , 93.89) 0
p-VALUE 0.7401 0.0027 - - 0.9700 0.8787 0.8182 -
Table 12: ML-CCA with mMVNNs (ML-CCA-mMVNN) and MVNNs (ML-CCA-MVNN) as the ML model architecture.
Shown are averages including the lower and upper 95%-bootstrapped CI bounds over a test set of 100 synthetic CA instances
for the SRVM and MRVM domains of the following metrics: efficiency in % for clock bids (ECLOCK), raised clock bids (ERAISE )
and raised clock bids plus 100 profit-max bids (EPR OFI T ) and percentage of instances where linear clearing prices were found
(CLE AR). Winners based on a paired t-test with α= 5% are marked in grey. The p-value for this pairwise t-test with H0:
µML-CCA-mMVNN ≤µML-CCA-MVNN shows at which significance level we can reject the null hypothesis of ML-CCA-MVNN
having a higher or equal average value in the corresponding metric than ML-CCA-mMVNN.
29