WSMS: Weighted Sums of Minimal Supports

• Weighted Sums of Minimal Supports (WSMS) is a framework that assigns responsibility scores to facts by aggregating weights from their minimal supports for a query answer.
• WSMS improves over traditional Shapley methods by using support-specific weights that prioritize smaller and more numerous supports, enhancing transparency and computational efficiency.
• Extensions of WSMS address unions with negation and ontology-mediated query answering, striking a balance between robust explanatory semantics and tractable data complexity.

Searching arXiv for the core WSMS paper and closely related follow-up work on negation and ontology-mediated query answering. Weighted Sums of Minimal Supports (WSMS) is a family of responsibility measures for query answers in relational databases. It assigns a numerical score to an endogenous fact by summing contributions from the query’s minimal supports that contain that fact, with each support weighted as a function of its size. WSMS was introduced to revisit Shapley-value-based responsibility for monotone non-numeric queries, with the explicit goals of improving interpretability and obtaining better complexity behavior than the standard drastic Shapley construction. Subsequent work extended the framework to unions of conjunctive queries with negation and to ontology-mediated query answering, while preserving the central support-based viewpoint (Bienvenu et al., 28 Mar 2025, Bienvenu et al., 8 Jan 2026, Bienvenu et al., 31 Jul 2025).

1. Responsibility analysis and the role of minimal supports

The basic setting is a finite relational database viewed as a set of ground facts. Responsibility analysis asks: given a query answer that holds in a database, how much did each input fact contribute to obtaining that answer? In the formulation underlying WSMS, the database is partitioned as $D = D_n \cup D_x$, where $D_n$ contains the endogenous facts among which responsibility is distributed and $D_x$ contains exogenous background facts. For a non-Boolean query $q$ with answer tuple $a$, one reduces to the Boolean query $q(a)$, since $D \models q(a)$ iff $a \in q(D)$. This reduction allows the framework to focus on Boolean monotone queries without loss of generality (Bienvenu et al., 28 Mar 2025).

For a monotone Boolean query $q$, a set $S$ is a support if it suffices to make the query true, and it is a minimal support if no proper subset still suffices. In the endogenous/exogenous setting, the relevant supports are subsets $D_n$0 such that $D_n$1, minimal under inclusion. The set of all minimal supports in a database $D_n$2 is denoted $D_n$3. A fact $D_n$4 is relevant iff $D_n$5 for some $D_n$6; otherwise it is irrelevant. These minimal supports are the semantic witnesses for the answer, and WSMS takes them as its primary explanatory objects rather than working through coalition averages over all fact subsets (Bienvenu et al., 28 Mar 2025).

This support-based orientation was motivated by two criticisms of the standard drastic Shapley approach. First, computing drastic Shapley responsibility is FP-$D_n$7P-hard / $D_n$8P-hard in data complexity even for simple conjunctive queries. Second, the drastic wealth function distributes a fixed total wealth $D_n$9 whenever the answer holds, which can make a fact’s score sensitive to supports that do not contain that fact. WSMS replaces that global competition for fixed wealth with direct aggregation over the minimal supports that actually involve the fact under inspection (Bienvenu et al., 28 Mar 2025).

2. Formal definition and weighting principles

The central definition uses a weight function

$D_x$0

For an endogenous fact $D_x$1, the WSMS score is

$D_x$2

and $D_x$3 otherwise. The intended semantics is direct: enumerate all minimal supports containing $D_x$4, attach to each such support a weight depending on its size and possibly on $D_x$5, and sum the resulting contributions (Bienvenu et al., 28 Mar 2025).

For the main semantic results, the weight function is assumed to be positive and strictly decreasing in support size: $D_x$6 Thus smaller minimal supports receive larger per-support weight. A weight function is called tractable if it is computable in polynomial time. WSMS is deliberately not normalized to sum to $D_x$7 over all facts. Responsibility mass is not fixed independently of witness structure: if an answer has many minimal supports, there can be more total responsibility to distribute. This is a defining departure from drastic Shapley responsibility (Bienvenu et al., 28 Mar 2025).

Several concrete weights are singled out. The inverse-size weight

$D_x$8

yields the especially natural score

$D_x$9

Two additional weights were proposed to emphasize different orderings of explanatory preference: $q$0 to prioritize smallest supports lexicographically, and

$q$1

to prioritize the number of minimal supports. The original analysis proves that $q$2 enforces preference for smaller smallest supports, while $q$3 enforces preference for appearing in more minimal supports (Bienvenu et al., 28 Mar 2025).

The resulting interpretation is compact. A fact receives a high WSMS score if it appears in many minimal supports, in small minimal supports, or both. In the motivating examples, a fact appearing in one singleton support outranks facts appearing only in one support of size $q$4, and a fact appearing in two size-$q$5 supports outranks a fact appearing in only one size-$q$6 support. Under $q$7, these become exact numerical comparisons such as $q$8 versus $q$9, or $a$0 versus $a$1 again through $a$2 versus $a$3 (Bienvenu et al., 28 Mar 2025).

3. Axiomatic behavior and relation to the Shapley value

WSMS was designed as a response to Shapley-based responsibility, but it is not anti-Shapley. The original analysis first isolates database analogues of classical Shapley axioms that remain compelling: $a$4, requiring semantically equivalent facts in semantically equivalent queries to receive the same score, and $a$5, requiring irrelevant facts to receive $a$6 and relevant facts to receive positive score. It then motivates support-sensitive principles: $a$7, that appearing in smaller minimal supports should increase responsibility, and $a$8, that appearing in more minimal supports should increase responsibility. A concrete test axiom, $a$9, formalizes these intuitions in a clean noninteracting configuration. If $q(a)$0 is positive and strictly decreasing, then $q(a)$1 satisfies $q(a)$2, $q(a)$3, and $q(a)$4 (Bienvenu et al., 28 Mar 2025).

The decisive conceptual result is that every WSMS measure is representable as a Shapley value for a suitably chosen cooperative game. For the inverse-size weight, the associated wealth function family is

$q(a)$5

and $q(a)$6 otherwise. On purely endogenous databases, this simplifies to

$q(a)$7

The corresponding Shapley value satisfies

$q(a)$8

when $q(a)$9, and $D \models q(a)$0 otherwise. This is the MS Shapley value (Bienvenu et al., 28 Mar 2025).

More generally, for every WSMS $D \models q(a)$1 and every positive Shapley-like score $D \models q(a)$2, there exists a family $D \models q(a)$3 such that

$D \models q(a)$4

The construction is explicit. For a set of minimal supports $D \models q(a)$5, one defines

$D \models q(a)$6

and chooses $D \models q(a)$7 so that the Shapley-like score of each singleton-support subgame contributes exactly $D \models q(a)$8. The philosophical consequence is precise: the problematic element in drastic Shapley responsibility is not the Shapley value itself, but the drastic wealth function used to encode Boolean query truth (Bienvenu et al., 28 Mar 2025).

4. Computational complexity and algorithmic methods

A central reason for introducing WSMS is that its computation reduces to counting minimal supports by size rather than averaging marginal contributions over exponentially many coalitions. For a tractable weight function $D \models q(a)$9, computing the score of a fact $a \in q(D)$0 reduces to obtaining, for each $a \in q(D)$1, the number of size-$a \in q(D)$2 minimal supports containing $a \in q(D)$3, and then summing

$a \in q(D)$4

Accordingly, if a query is bounded—meaning that the size of its minimal supports is bounded by a constant independent of the database—then WSMS is in $a \in q(D)$5. Since all UCQs are bounded, WSMS has polynomial-time data complexity for all UCQs. This sharply contrasts with drastic Shapley responsibility, which remains $a \in q(D)$6P-hard in data complexity even for simple conjunctive queries (Bienvenu et al., 28 Mar 2025).

The paper also gives more refined results. For regular path queries, WSMS is in $a \in q(D)$7 on acyclic graph databases via dynamic programming that counts paths of a given size, but on arbitrary graphs there is a dichotomy: for reversible tractable weight functions, the problem is in $a \in q(D)$8 only when the language $a \in q(D)$9 is finite or $q$0 and $q$1, and is $q$2P-hard otherwise. For arbitrary monotone query classes whose evaluation lies in the polynomial hierarchy, there is a general upper bound

$q$3

Thus WSMS is not uniformly easy in combined complexity (Bienvenu et al., 28 Mar 2025).

For conjunctive queries, the combined-complexity picture is mixed. Counting minimal supports is $q$4P-hard already for acyclic conjunctive queries, yielding $q$5P-hardness of WSMS for acyclic CQs under reversible weights. On the positive side, self-join-free acyclic CQs are tractable because minimal supports and homomorphisms coincide, and more generally any class of CQs with bounded generalized hypertree width and bounded self-join width admits polynomial-time computation of both fixed-size minimal-support counts and WSMS. The underlying proof technique is structural: with self-joins, the analysis uses auxiliary CQs with equalities and disequalities, mergeable atoms, equivalence relations on mergeable terms, and homomorphism-counting algorithms for bounded-width classes (Bienvenu et al., 28 Mar 2025).

The basic bounded-query algorithm is correspondingly simple: enumerate all subsets $q$6 up to the support-size bound, test whether $q$7, test minimality, and add $q$8 to the score of each $q$9. The tractable cases are therefore driven by efficient counting of minimal explanations of each size rather than by direct Shapley permutation summation (Bienvenu et al., 28 Mar 2025).

5. Extensions to conjunctive queries with negation

Once negation is allowed, there is no single natural notion of support. For $S$0, two principled WSMS-style extensions were introduced: a signed-facts extension and a positive-facts extension. The signed construction transforms a query $S$1 into a monotone query $S$2 over a signed schema with positive relations $S$3 and negative relations $S$4, and transforms a database $S$5 into

$S$6

A signed support is any $S$7 such that $S$8, and signed WSMS simply applies the monotone WSMS definition to these minimal signed supports. Responsibility is then assigned to signed facts, including absent tuples represented as negative facts (Bienvenu et al., 8 Jan 2026).

The positive-facts extension scores only actual database facts. A subset $S$9 is a positive support if

$D_n$00

so the positive atoms are witnessed by $D_n$01 while the negated atoms are checked against absence in the full database context. The resulting positive WSMS sums $D_n$02 over minimal positive supports containing the fact. For $D_n$03, this yields the paper’s positive MS-Shapley measure. The two variants reflect different explanatory semantics: signed supports explain truth through presence and absence, whereas positive supports explain truth using only present tuples while validating negations against the ambient database (Bienvenu et al., 8 Jan 2026).

These definitions were motivated by the failure of naive monotone-style supports under negation. A subinstance $D_n$04 may satisfy a non-monotone query only because some blocking fact is absent from $D_n$05 even though it is present in the full database. The signed and positive notions reject that behavior in different ways. The signed approach is computationally the cleaner of the two because it reduces directly to monotone WSMS on $D_n$06 and $D_n$07. The positive approach is semantically stricter when only actual tuples are to be scored (Bienvenu et al., 8 Jan 2026).

In complexity terms, both extensions preserve an important tractability result: signed MS/WSMS is polynomial-time computable in data complexity for all $D_n$08, and positive MS/WSMS is polynomial-time computable in data complexity for all $D_n$09 as well. In combined complexity, signed WSMS is tractable for classes of $D_n$10 with bounded negative arity, bounded generalized hypertree width, and bounded self-join width; positive WSMS is tractable for classes with bounded generalized hypertree width, no mergeable atoms, and bounded negative arity, and also for guarded $D_n$11 classes with bounded generalized hypertree width and no mergeable atoms. All these upper bounds extend from MS-Shapley to WSMS with tractable weights (Bienvenu et al., 8 Jan 2026).

Variant	Support notion	Scored objects
Original WSMS	Minimal supports of monotone $D_n$12 in $D_n$13	Facts $D_n$14
Signed WSMS	Minimal signed supports of $D_n$15 in $D_n$16	Signed facts $D_n$17
Positive WSMS	Minimal positive supports in ambient $D_n$18	Facts $D_n$19

6. Ontology-mediated query answering, tradeoffs, and scope

WSMS has also been transferred to ontology-mediated query answering (OMQA), where the ABox is treated as the fact set and the ontology-mediated query $D_n$20 replaces the plain database query. A subset $D_n$21 is a support if $D_n$22, and is minimal if no proper subset still entails the answer under the fixed ontology $D_n$23. In this setting, ontology reasoning can fundamentally change support structure through indirect entailment, anonymous canonical-model elements, and interactions between query atoms mediated by the ontology (Bienvenu et al., 31 Jul 2025).

The main positive data-complexity result is that WSMS is in $D_n$24 for every tractable weight function and every Boolean OMQ that is $D_n$25-rewritable. This implies polynomial data complexity for important DL-Lite settings. The reason is the same bounded-support phenomenon seen in the plain database setting: if the OMQ rewrites into a $D_n$26, then minimal supports are bounded in size. The paper also shows that fixed-size minimal-support counting can be reduced to finitely many homomorphism-counting queries, so WSMS for UCQ-rewritable OMQs can be implemented via short SQL select count(*) queries evaluated in parallel (Bienvenu et al., 31 Jul 2025).

The negative side is equally sharp. If the ontology language can express an axiom such as

$D_n$27

then there exists an atomic OMQ for which WSMS is $D_n$28-hard in data complexity, by simulating reachability. In combined complexity, intractability appears already for atomic queries if the ontology language supports conjunction, and also for acyclic self-join-free UCQs even without any ontology. On the positive side, atomic OMQs over DLs with singleton supports—especially $D_n$29—remain tractable, and a substantial tractable fragment is obtained for interaction-free DL-Lite conjunctive queries of bounded treewidth (Bienvenu et al., 31 Jul 2025).

These developments clarify the main tradeoff in the WSMS program. Relative to drastic Shapley responsibility, WSMS gains semantic locality and, in many important settings, significantly better data complexity. The tradeoff is that WSMS deliberately ignores higher-order interaction structure among minimal supports that coalition-based measures can capture. The original formulation does not claim that drastic Shapley is unreasonable; rather, it presents WSMS as a different, support-centered notion of responsibility that is often simpler and more tractable. In the original monotone presentation, extending the framework beyond monotone queries was left for future work; subsequent work on $D_n$30 shows that such extensions are possible, but only after making explicit choices about what should count as a support in the presence of negation (Bienvenu et al., 28 Mar 2025, Bienvenu et al., 8 Jan 2026).