Even-if Explanations: Formal Foundations, Priorities and Complexity
Gianvincenzo Alfano , Sergio Greco , Domenico Mandaglio , Francesco Parisi ,
Reza Shahbazian and Irina Trubitsyna
DIMES Department, University of Calabria, Rende, Italy
{g.alfano, greco, d.mandaglio, fparisi, i.trubitsyna}@dimes.unical.it reza.shahbazian@unical.it
Abstract
EXplainable AI has received significant attention
in recent years. Machine learning models of-
ten operate as black boxes, lacking explainabil-
ity and transparency while supporting decision-
making processes. Local post-hoc explainability
queries attempt to answer why individual inputs
are classified in a certain way by a given model.
While there has been important work on counter-
factual explanations, less attention has been de-
voted to semifactual ones. In this paper, we fo-
cus on local post-hoc explainability queries within
the semifactual ‘even-if’ thinking and their com-
putational complexity among different classes of
models, and show that both linear and tree-based
models are strictly more interpretable than neural
networks. After this, we introduce a preference-
based framework that enables users to personalize
explanations based on their preferences, both in the
case of semifactuals and counterfactuals, enhanc-
ing interpretability and user-centricity. Finally, we
explore the complexity of several interpretability
problems in the proposed preference-based frame-
work and provide algorithms for polynomial cases.
1 Introduction
The extensive study of counterfactual ‘if only’ thinking, ex-
ploring how things might have been different, has been a focal
point for social and cognitive psychologists [Kahneman and
Tversky, 1981; McCloy and Byrne, 2002]. Consider a neg-
ative event, such as taking a taxi and due to traffic arriving
late to a party. By analyzing this situation, an individual (e.g.
Alice) might engage in counterfactual thinking by imagining
how things could have unfolded differently, such as, ‘if only
Alice had not taken the taxi, she would not have arrived late
at the party’. This type of counterfactual thinking, where an
alternative scenario is imagined, is a common aspect of daily
life. In such a case the counterfactual scenario negates both
the event’s cause (antecedent) and its outcome, presenting a
false cause and a false outcome that are temporarily consid-
ered as true (e.g., Alice took the taxi and arrived late).
Counterfactual thinking forms the basis for crafting coun-
terfactual explanations, which are crucial in automated
x1 = [0, 1, 1]
[0,0,1]
[1,1,1]
f3
[1,0,1]
f2
y1 = [0, 0, 0] y2 = [1, 1, 0]
f1
[1,0,0]
Figure 1: Binary classification model M : step(x · [ 2, 2, 0] + 1)
of Example 1 representing the mortgage scenario. The binary fea-
ture f1 (resp., f2 and f3 ) represents part-time employment contract
(resp., mortgage term longer than 30 years, and on site-working).
Crosses (resp., circles) on the corners of the green (resp., red) area
correspond to instances where the model outputs 1 (resp., 0).
decision-making processes. These explanations leverage
imagined alternative scenarios, aiding users in understanding
why certain outcomes occurred and how different situations
might have influenced automated decisions. Counterfactual
explanations empowers users to grasp the rationale behind
automated decisions, fostering transparency and user trust in
these systems. Several definitions of counterfactual explana-
tions exist in the literature [Guidotti, 2022]. According to
most of the literature, counterfactuals are defined as the mini-
mum changes to apply to a given instance to let the prediction
of the model be different [Barceló et al., 2020].
While significant attention in AI has been given to coun-
terfactual explanations, there has been a limited focus on the
equally important and related semifactual ‘even if’ expla-
nations [Aryal and Keane, 2023; Kenny and Huang, 2023],
though they have been investigated much more in cognitive
sciences. While counterfactuals explain what changes to the
input features of an AI system change the output decision,
semifactuals show which input feature changes do not change
a decision outcome. Considering the above-mentioned situ-
ation where Alice took the taxi and arrived late at the party,
we might analyze ‘even if’ scenarios envisioning how things
could have remained the same, such as, “even if Alice had not
taken a taxi, she would have still arrived late at the party”.
Sharing the same underlying idea of counterfactuals, we
define semifactuals as the maximum changes to be applied
to a given instance while keeping the same prediction. In-
deed, the larger the feature differences asserted in the semi-
factual, the better (more convincing) the explanation [Aryal
and Keane, 2023]. This intuitively captures the desire of an
agent to have more degree of freedom and favorable condi-
tions (represented by features changed), while keeping the
(positive) status assigned to it by the model. As an example,
consider the following, inspired by a mortgage scenario.
Example 1. Consider the binary and linear classification
model M : {0, 1}3 {0, 1} shown in Figure 1 where M
is defined as step(x · [⇥2, 2, 0] + 1). The three features are:
• f1 =“user’s employment contract is part-time”,
• f2 =“user applies for a mortgage whose duration is
longer than 30 years”, and
• f3 =“user works on-site”.
For any instance x ⇤ {0, 1}3 we have that M(x) = 0 if
x = [1, 0, 1] or x = [1, 0, 0], and M(x) = 1 otherwise.
Intuitively, this means that the bank’s model does not approve
the mortgage only when the user has a part-time job and the
requested mortgage duration is less than 30 years.
Consider a user x1 that works full-time, on-site, and re-
quests a mortgage with duration longer than 30 years (i.e.,
x1 = [0, 1, 1]), we have that y1 = [0, 0, 0] and y2 = [1, 1, 0]
are semifactual of x1 w.r.t. M at maximum distance (i.e., 2)
from x1 in terms of number of feature changed. Intuitively,
y1 represents ‘the user x1 will obtain the mortgage even if
the work would have been remote and the mortgage duration
would have been less than 30 years’, while y2 represents ‘the
user x1 will obtain the mortgage even if the work would have
been part-time and she would have worked remotely’.
However, as highlighted in the previous example, multi-
ple semifactuals can exist for each given instance. In these
situations, a user may prefer one semifactual to another, by
expressing preferences over features so that the best semifac-
tuals will be selected, as shown in the following example.
Example 2. Continuing with the previous example, suppose
that the user x1 prefers semifactuals with f1 = 1 rather than
those with f2 = 0, that is (s)he prefers to change feature f1
rather than f2 (irrespective of any other change). Thus, (s)he
would prefer to still get a mortgage by changing the job to
part-time (obtaining y2 ); if this cannot be accomplished, then
(s)he prefers to get a mortgage by changing the duration to be
less than or equal to 30 years (obtaining y1 ).
Prioritized reasoning in AI, focusing on incorporating user
preferences, represents a pivotal advancement in the field, en-
hancing adaptability and user-centricity of AI systems. Tra-
ditional AI models rely on predefined rules or optimiza-
tion criteria to generate outcomes, often overlooking the nu-
anced nature of user-specific preferences [Rossi et al., 2011;
Santhanam et al., 2016]. Prioritized reasoning addresses this
limitation by introducing a mechanism that allows users to ex-
press their preferences, thereby guiding AI systems to prefer
specific factors over others in the decision-making processes.
One key aspect of prioritized reasoning is its appli-
cability across diverse AI domains, spanning machine
learning [Kapoor et al., 2012], natural language process-
ing [Bakker et al., 2022], and recommendation systems [Zhu
et al., 2022]. In machine learning, for instance, the ability
to prioritize specific features or outcomes based on user pref-
erences significantly improves the relevance and usability of
the resulting models. Within natural language processing,
prioritized reasoning facilitates customized language gener-
ation aligned with individual preferences, catering to diverse
communication styles. The impact of prioritized reasoning
extends to recommendation systems, where user preferences
play a crucial role in shaping the suggestions provided.
Our work contributes to prioritized reasoning within ex-
plainable AI in the presence of user’s preference conditions
related to features. These preferences are exploited to gen-
erate semifactual and counterfactual explanations that align
most closely with the user-specified criteria. In particular,
preferences are applied similarly to what has been proposed
in the well-known Answer Set Optimization approach for
Logic Programs with preferences [Brewka et al., 2003].
Contributions Our main contributions are as follows.
• We formally introduce the concepts of semifactual over
three classes of models: (i) perceptrons (ii) free bi-
nary decision diagrams (FBBDs), and (iii) multi-layer
perceptrons (MLP), intuitively encoding local post-hoc
explainable queries within the even-if thinking setting.
Herein, the term ‘local’ refers to explaining the output of
the system for a particular input, while ‘post-hoc’ refers
to interpreting the system after it has been trained.
• We first investigate the computational complexity of in-
terpretability problems concerning semifactuals, show-
ing that they are not more difficult than analogous prob-
lems related to counterfactuals [Barceló et al., 2020].
• We introduce a framework that empowers users to pri-
oritize explanations according to their subjective pref-
erences. That is, users can specify preferences for al-
tering specific features over others within explanations.
This approach enriches the explanation process, en-
abling users to influence the selection of the most favor-
able semifactuals (called “best” semifactuals), thereby
augmenting the interpretability and user-centricity of the
resulting outputs. Notably, the proposed framework also
naturally encompasses preferences over counterfactuals.
• We investigate the complexity of several interpretability
problems related to best semifactuals and best counter-
factuals. Table 1 summarizes our complexity results. Fi-
nally, focusing on a restricted yet expressive class of fea-
ture preferences, we identify tractable cases for which
we propose algorithms for their computation.
Full proofs can be found in the Supplementary Material.
2 Preliminaries
We start by recalling the key concepts underlying counterfac-
tual and semifactual explanations, and then we recall the main
complexity classes used in the paper.
2.1 Classification Models
A (binary classification) model is a function M : {0, 1}n
{0, 1}, specifically focusing on instances whose features are
represented by binary values. Constraining inputs and out-
puts to booleans simplifies our context while encompassing
numerous relevant practical scenarios. A class of models is
just a way of grouping models together. An instance x is a
vector in {0, 1}n and represents a possible input for a model.
We now recall three significant categories of ML models,
that hereafter will be the one we will focus on.
Binary Decision Diagrams. A Binary Decision Diagram
(BDD) M = (V, E, V , E ) [Wegener, 2004] is a rooted di-
rected acyclic graph (V, E). It features leaves labeled true
(⌅) or false (⇧), and internal nodes labeled by function V
with a value from {1, . . . , n}, each of them having two out-
going edges labeled by function E as 1 and 0, respectively.
Each instance x = [x1 , . . . , xn ] ⇤ {0, 1}n uniquely maps to
a path px in M. This path adheres to the following condi-
tion: for every non-leaf node u in px labeled i, the path goes
through the edge labeled with xi . |M| denotes the size of M,
representing the number of edges. A binary decision diagram
M is free (FBDD) if for every path from the root to a leaf, no
two nodes on that path have the same label. A decision tree
is simply an FBDD whose underlying graph is a tree.
Multilayer Perceptrons. A multilayer perceptron (MLP)
M with k layers is defined by a sequence of weight matrices
W(1) , . . . , W(k) , bias vectors b(1) , . . . , b(k) , and activation
functions a(1) , . . . , a(k) . Given an instance x, we inductively
define h(i) = a(i) (h(i 1) W(i) + b(i) ) with i ⇤ {1, . . . , k},
assuming that h(0) = x. The output of M on x is defined
as M(x) = h(k) . In this paper we assume all weights and
biases to be rational numbers, i.e. belonging to Q. We say
that an MLP as defined above has (k ⇥ 1) hidden layers. The
size of an MLP M, denoted by |M|, is the total size of its
weights and biases, in which the size of a rational number pq
is log2 (p) + log2 (q) (with the convention that log2 (0) = 1).
We focus on MLPs in which all internal functions
a(1) , . . . , a(k 1) are the ReLU function relu(x) =
max(0, x). Usually, MLP binary classifiers are trained using
the sigmoid as the output function a(k) . Nevertheless, when
an MLP classifies an input (after training), it takes decisions
by simply using the preactivations, also called logits. Based
on this and on the fact that we only consider already trained
MLPs, we can assume w.l.o.g. that the output function a(k)
is the binary step function, defined as step(x) = 0 if x < 0,
and step(x) = 1 if x ⌃ 0.
Perceptrons. A perceptron is an MLP with no hidden lay-
ers (i.e., k = 1). That is, a perceptron M is defined by a
pair (W, b) such that W ⇤ Qn◊1 and b ⇤ Q, and the out-
put is M(x) = step(x W + b). Because of its particular
structure, a perceptron is usually defined as a pair (w, b) with
w = WT a rational vector and b a rational number. The out-
put of M(x) is then 1 iff x · w + b ⌃ 0, where x · w denotes
the dot product between x and w.
2.2 Complexity Classes
Boolean functions F mapping strings to strings whose output
is a single bit are called decision problems. We identify the
computational problem of computing F (i.e., given an input
string x compute F(x)) with the problem of deciding whether
F(x) = 1. As an example of F, consider to take as input a
graph G and a number k and return 1 whether there exists a
set of vertices each-other not adijacent of size at least k. This
decision problem is known as I NDEPENDENT S ET.
We recall the complexity classes used in the paper and, in
particular, the definition of the classes PTIME (or, briefly, P),
NP and coNP (see e.g. [Papadimitriou, 1994]). P (resp.,
NP) contains the set of decision problems that can be solved
in polynomial time by a deterministic (resp., nondeterminis-
tic) Turing machine. Moreover, coNP is the complexity class
containing the complements of problems in NP. A problem p
is called hard for a complexity class C (denoted C-hard) if
there exists a polynomial reduction from any problem in C to
p. If p is both C-hard and belongs to C then it is C-complete.
Clearly, P⌥ NP, P⌥ coNP and, under standard theoretical as-
sumptions, the three classes are assumed to be different.
3 Even-if Explanations
In this section, we instantiate our framework on three im-
portant classes of boolean models and explainability queries.
Subsequently, we present our main theorems, facilitating a
comparison of these models in terms of their interpretability.
We start by recalling the notion of counterfactual, that is
the explainability notion in the ‘if only’ case, whose com-
plexity has been investigated in [Barceló et al., 2020].
We define the distance measure between two instances
x, y ⇤ {0, 1}n as the number of features where they differ.
n
Formally, d(x, y) = i=1 |xi ⇥ yi | is the number of indexes
i ⇤ {1, . . . , n} (i.e., features) where x and y differ.
Definition 1 (Counterfactual). Given a pre-trained model M
and an instance x, an instance y is said to be a counterfac-
tual of x iff i) M(x) = M(y), and ii) there exists no other
instance z = y s.t. M(x) = M(z) and d(x, z) < d(x, y).
Example 3. Continuing with our running example (see Fig-
ure 1), for x1 = [0, 1, 1] we have that y3 = [1, 0, 1] is the only
counterfactual of x1 w.r.t. M (herein, d(x1 , y3 ) = 2).
The following represents the natural decision version of the
problem of finding a couterfactual for x [Barceló et al., 2020].
PROBLEM: M INIMUM C HANGE R EQUIRED (MCR)
INPUT: Model M, instance x, and k ⇤ N.
OUTPUT: Y ES, if there exists an instance y with
d(x, y) k and M(x) = M(y);
N O, otherwise.
Theorem 1 ([Barceló et al., 2020]). MCR is i) in PTIME for
FBDDs and perceptrons, and ii) NP-complete for MLPs.
We follow a standard assumption about the relationship
between model interpretability and computational complex-
ity [Barceló et al., 2020] which states that a class A of mod-
els is more interpretable than another class B if the computa-
tional complexity of addressing post-hoc queries for models
in B is higher than for those in A.
Under the lens of the aforementioned assumption, Theo-
rem 1 states that the class of models ‘perceptron’ and ‘FBDD’
is strictly more interpretable than the class ‘MLP’, as the
computational complexity of answering post-hoc queries for
models in the first two classes is lower than for those in the
latter. These results represent a principled way to confirm
the folklore belief that linear models are more interpretable
than deep neural networks within the context of interpretabil- Models of the form {0, 1}n ⇥ {0, 1}
ity queries for counterfactuals. FBDDs Perceptrons MLPs
An open question is whether the same holds when dealing MCR PTIME PTIME NP-c
with post-hoc queries based on the ’even-if’ thinking setting, MCA PTIME PTIME NP-c
i.e. on semifactuals. Before exploring this research question, BMCR PTIME PTIME NP-c
we formally introduce the concept of semifactual. BMCA PTIME PTIME NP-c
CBMCR coNP coNP coNP-c
Definition 2 (Semifactual). Given a pre-trained model M CBMCA coNP coNP coNP-c
and an instance x, an instance y is said to be a semifactual of L -CBMCR PTIME PTIME coNP-c
x iff i) M(x) = M(y), and ii) there exists no other instance L -CBMCA PTIME PTIME coNP-c
z = y s.t. M(x) = M(z) and d(x, z) > d(x, y).
Table 1: Complexity of explainability queries. For any class C, C-c
Similar to counterfactuals, the following problem is the de-
means C-complete. Grey-colored cells refer to known results.
cision version of the problem of finding a semifactual of an
instance x with a model M.
PROBLEM: M AXIMUM C HANGE A LLOWED (MCA)
4 Preferences over Explanations
INPUT: Model M, instance x, and k ⇤ N. The problem of preference handling has been extensively
OUTPUT: Y ES, if there exists an instance y with studied in AI. Several formalisms have been proposed to ex-
d(x, y) ⌃ k and M(x) = M(y); press and reason with different kinds of preferences [Brafman
N O, otherwise. and Domshlak, 2009; Rossi et al., 2011; Santhanam et al.,
2016]. In the field of logic programming under stable model
The complexity of MCA is as follows. semantics (a.k.a. Answer Set Programming - ASP), multi-
Theorem 2. MCA is i) in PTIME for FBDDs and percep- ple formalisms introducing preferences over atoms to filter
trons, and ii) NP-complete for MLPs. out models have been suggested. In the following, in order
Proof. (Sketch) (Perceptron). MCA (optimization) problem to express preferences over semifactuals and counterfactuals,
under perceptrons can be formulated in ILP as follows: we introduce a novel approach inspired to that proposed in
⇥ n n [Brewka et al., 2003] for ASP, whose semantics is based on
i=1 wi (2xi ⇥ 1)zi
n
i=1 wi xi the degree to which preference rules are satisfied.
max zi subject to
zi ⇤ {0, 1}, i = 1, . . . , n
i=1 Syntax. Input instances are of the form x = (x1 , ..., xn )
where zi = 1 if we decide to change the feature i, 0 other- in {0, 1}n . Each xi (with i ⇤ [1, n]) represents the value of
wise, for each i = 1, · · · , n. Notice that the above formu- feature fi , and the (equality) atom fi = xi denotes that the
lation corresponds to the standard (max-) Knapsack problem value of feature fi in x is equal to xi .
where each item has value 1 and weight wi (2xi ⇥ 1), and the A simple preference is an expression of the form (fi =
n
bag has capacity i=1 wi xi . The Knapsack problem is, in x⇥i ) (fj = x⇥⇥j ); it intuitively states that we prefer semi-
the general case, NP-Hard [Papadimitriou, 1994]. However, factuals (resp., counterfactuals) where fi = x⇥i w.r.t. those
MCA corresponds to a special instance of Knapsack where where fj = x⇥⇥j . To simplify the notation, an equality atom
every item has the same cost that can be solved in polynomial of the form fi = 1 is written as a positive atom fi , whereas
time with a greedy strategy, from which the result follows. an atom of the form fi = 0 is written as a negated atom ¬fi .
(FBDD). Let Mu be the FBDD obtained by restricting Positive and negated atoms are also called (feature) literals.
M to the nodes that are (forward-)reachable from u and Definition 3 (Preference rule). Let I = {f1 , ..., fn } be the
mcau (x) = max{k ⇥ | ⌦y. d(x, y) = k ⇥ ↵ Mu (y)=M(x)} set of input features. A preference rule is of the form:
(that can be comptuted in PTIME). For y maximizing k ⇥ it
holds that yu = xu holds u⇥ from the root of M to u ex- ⇥1 ··· ⇥k ⇥k+1 ↵ · · · ↵ ⇥m (1)
cluded. Let r be the root of M. Then, we can show that
with m ⌃ k ⌃ 2, and any ⇥i ⇤ {f1 , ¬f1 , . . . fn , ¬fn } is a
(M, x, k) is a positive instance of MCA iff mcar (x) ⌃ k.
(feature) literal, with i ⇤ [1, n].
(MLP) The following algorithm provides the membership in
NP. Guess an instance y and check in PTIME that d(x, y) In (1), ⇥1 ··· ⇥k is called head (or consequent),
⌃ k and M(x) = M(y). We prove the hardness with a poly- whereas ⇥k+1 ↵ · · · ↵ ⇥m is called body (or antecedent). We
nomial reduction from I NDEPENDENT S ET, which is known assume that literals in the head are distinct. Intuitively, when-
to be NP-complete [Papadimitriou, 1994]. ever ⇥k+1 , · · · , ⇥m are true, then ⇥1 is preferred over ⇥2 ,
which is preferred over ⇥3 , and so on until ⇥k 1 which is
It turns out that, under standard complexity assumptions, preferred over ⇥k . As usual, when the body of the rule is
computing semifactuals under perceptrons and FBDDs is eas- empty, the implication symbol is omitted.
ier than under multi-layer perceptrons. Moreover, indepen-
dently of the type of the model, computing semifactuals is Definition 4 (BCMP framework). A (binary classification)
as hard as computing counterfactuals (cf. Table 1). Thus, model with preferences (BCMP) framework is a pair (M, )
perceptrons and FBDDs are strictly more interpretable than where M is a model and 1 a set of preference rules over
MLPs, in the sense that the complexity of answering post- features of M.
hoc queries for models in the first two classes is lower than 1
With a little abuse of notation, we use ⇤ to denote both a set of
for those in the latter. preference and the preference relation among feature literals.
Example 4. The BCMP framework 1 = (M, {f1 ¬f2 }),
where M is the model presented in Example 1, encodes the
user’s preference specified in Example 2. Consider now the
framework 2 obtained from 1 by replacing the preference
rule with f1 ¬ f2 ¬f3 . Intuitively, this preference rule
encodes a user preference for explanations where, whenever
the work is not on-site (i.e., ¬f3 holds), (s)he prefers semifac-
tuals/counterfactuals where the contract is part-time (i.e., f1
holds) and, if this is not possible, (s)he prefers those where the
mortgage duration is not longer than 30 years (i.e., ¬f2 ).
Semantics. The preference rules determine a preference or-
dering ✏ on the semifactual/counterfactual explanations of an
instance x w.r.t. a model M, as shown in what follows.
Let us consider a semifactual or counterfactual explanation
y and a preference ⇤ of the form (1), the following three sit-
uations are possible:
(a) the body of ⇤ is not satisfied in y;2
(b) the body of ⇤ is satisfied in y and at least one head literal
is true in y;
(c) the body of ⇤ is satisfied in y and none of the head liter-
als is satisfied in y.
In the cases a) and b) we say that y satisfies ⇤ respectively
with degree 1 and min({l | y satisfies ⇥l with l k}) (de-
noted as ⌅(y, ⇤)), while in case (c) we say that y does not sat-
isfy ⇤ and the associated degree is ⌅(y, ⇤) = +⇣. Intuitively,
⌅(y, ⇤) represents the position of the first feature literal sat-
isfied in the ordered list provided in the head of a preference
rule; however, it can be 1 if y satisfies the first literal ⇥1 or if
the rule is irrelevant (case a). If the rule is relevant (the body
is satisfied) and no head literal is satisfied, then it is +⇣.
Thus, given a BCMP framework (M, ), an instance x and
two (semifactual/counterfactual) explanations y and z for M
and x, we write y ✏ z iff ⌅(y, ⇤) ⌅(z, ⇤) for all preference
⇤ in , and write y ⇥ z iff y ✏ z and z ✏ y.
Definition 5 (Semantics). Given a BCMP framework (M, )
and an instance x. We say that y is a best semifactual (resp.,
counterfactual) explanation of x if y is a semifactual (resp.,
counterfactual) of x and there is no other semifactual (resp.,
counterfactual) z of x such that z ⇥ y.
Example 5. Continuing with Example 4, considering the in-
stances y1 = [0, 0, 0] and y2 = [1, 1, 0], we have that y1 and
y2 satisfy ⇤ = f1 ¬ f2 ¬f3 with degree ⌅(y1 , ⇤) = 2
and ⌅(y2 , ⇤) = 1 since the second and first literal in the head
of ⇤ is satisfied in y1 and y2 , respectively, and the body of ⇤
is satisfied by both of them. Then, y2 ⇥ y1 , and thus y2 is
the only best semifactual of x.
4.1 Computational Complexity
We now investigate the complexity of several problems re-
lated to prioritized reasoning for explanations in order to
compare model classes, even under prioritized reasoning.
We start by introducing the following lemma that will be
used in the proof of the next theorems. Intuitively, the lemma
states that checking whether y ✏ z can be done in PTIME.
2
A positive (resp., negative) atom fi (resp., ¬fi ) is satisfied in
y = (y1 , . . . , yn ) whenever yi = 1 (resp., yi = 0).
Lemma 1. For any framework (M, ) and instances y, z of
M, deciding whether y ⇥ z can be done in PTIME.
The next two problems ask if there exists a best explanation
in the even-if and if-only thinking, respectively.
PROBLEM: B EST MCR (BMCR)
INPUT: BCMP framework (M, ), instance x,
and k ⇤ N.
OUTPUT: Y ES, if there exists an instance y with
d(x, y) k and M(x) = M(y) that is
best w.r.t. ✏; N O, otherwise.
PROBLEM: B EST MCA (BMCA)
INPUT: BCMP framework (M, ), instance x,
and k ⇤ N.
OUTPUT: Y ES, if there exists an instance y with
d(x, y) ⌃ k and M(x) = M(y) that is
best w.r.t. ✏; N O, otherwise.
Theorem 3. BMCR and BMCA are i) in PTIME for FB-
DDs and perceptrons, and ii) NP-complete for MLPs.
Thus, preferences do not make the existence problem
harder. Consider now the problems of checking whether a
given instance y is a best counterfactual or semifactual of x.
PROBLEM: C HECK B EST MCR (CBMCR)
INPUT: BCMP (M, ), instances x, y with
d(x, y) = k, and M(x) = M(y).
OUTPUT: Y ES, if there is no z with M(x) = M(z)
and either d(x, z) k ⇥ 1, or d(x, z) = k
and z ⇥ y; N O, otherwise
PROBLEM: C HECK B EST MCA (CBMCA)
INPUT: BCMP (M, ), instances x, y with
d(x, y) = k, and M(x) = M(y).
OUTPUT: Y ES if there is no z with M(x) = M(z)
and either d(x, z) ⌃ k + 1 or d(x, z) = k
and z ⇥ y; N O, otherwise.
Theorem 4. CBMCR and CBMCA are i) in coNP for FB-
DDs and perceptrons, and ii) coNP-complete for MLPs.
We now focus on a simpler yet expressive class of BCMPs
where a fixed linear order is defined over a subset of features.
Definition 6 (Linear BCMP framework). A linear (binary
classification) model with preferences framework is a pair
(M, ) where M is a model, and consists of a linear pref-
erence rule, that is a single preference rule of the form (1)
with empty body.
Example 6. Considering Example 4, the BCMP framework
1 is linear, whereas 2 is not.
We use L -CBMCA and L -CBMCR to denote CBMCA
and CBMCR where the input BCMP is linear. The follow-
ing theorem states that linear preferences do not increase the
complexity in the case of perceptrons and FBDDs, though
they allow expressing user-specific desiderata among queries.
Theorem 5. L -CBMCA and L -CBMCR are in PTIME for
perceptrons and FBDDs.
Algorithm 1 Computing a (best) semifactual for perceptrons
Input: Perceptron M = (W, b), instance x ⇤ {0, 1}n , and
linear preference ⇤ = fp1 · · · fpl .
Output: A best semifactual y for x w.r.t. M and ⇤.
1: Let s = [f1 /s1 , . . . , fn /sn ] where i ⇤ [1, n],
si = 2xi wi ⇥ wi if M(x) = 1, wi ⇥ 2xi wi otherwise;
2: Let s⇥ = [fq1 /sq1 , ..., fqn /sqn ] be the sorted version of s
in ascending order of si ;
3: k = max({i ⇤ [0, n] | M(flip(x, pos(s⇥ , i))=M(x)});
4: if k = 0 return x;
5: if k = n return [1 ⇥ x1 , . . . , 1 ⇥ xn ];
6: y = flip(x, pos(s⇥ , k));
7: ⌅ = min({i ⇤ [1, l] | ypi = 1} ⌘ {l + 1});
8: for i ⇤ [1, ..., ⌅ ⇥ 1] do
9: if ypi = 1 return y;
10: Let j = q1 if xpi = ypi , j = qk+1 otherwise;
11: z = flip(y, {pi , j});
12: if M(x) = M(z) return z;
13: return y;
4.2 Computation
We now introduce two algorithms for computing a best semi-
factual instance for perceptrons and FBDDs, respectively.
Both algorithms take as input a model M, an instance x, and
a linear preference ⇤, and returns a best semifactual explana-
tion. For the sake of the presentation, w.l.o.g., we assume that
head literals are positive atoms (i.e., ⇥i = fi for all i).
We start with Algorithm 1 for the perceptron model.
Initially, a list s of pairs feature/weight is built, where the
each weight takes into account the contribution of the associ-
ated feature to the result (Line 1). At Line 2 the list is sorted in
ascending order of weights, giving a new list s⇥ . Next the fea-
ture values of x are changed to get a semifactual instance y.
To change a maximum number k of feature values of x, guar-
anteeing that the output of the model M(x) does not change,
the order in s⇥ is followed. To this end, the following func-
tions are introduced: i) pos(s⇥ , i), computing the set of the
positions in s of the first i features in s⇥ , and ii) flip(y, B),
with y = [y1 , ..., yn ], updating every element yi such that
i ⇤ B with the complementary value 1⇥yi . Notice that k = 0
means that x is the only semifactual for x, (returned at Line
4), whereas k = n means that [1 ⇥ x1 , . . . , 1 ⇥ xn ] is the only
semifactual for x (returned at Line 5). At Line 7 the degree of
satisfaction of ⇤ by y is computed; if no feature in ⇤ is satis-
fied by y the degree is l+1 (standing for +⇣). The next steps
(Lines 8-13) search for a better semifactual instance (if any).
This is carried out by considering the first ⌅ ⇥ 1 features in ⇤.
Thus, for each feature fpi in ⇤ (i ⇤ [1, ⌅ ⇥ 1]) we have that:
i) if y satisfies fpi , y is a best semifactual and it is returned
at Line 9; ii) otherwise an alternative instance z satisfying
feature fpi is generated and, if it is a semifactual then it is
returned at Line 12. In particular, z is a semifactual instance
only if d(z, x) = d(y, x) and M(z) = M(x). To guaran-
tee that d(z, x) = d(y, x) we either restore feature fq1 in y
by setting it back to yq1 = xq1 whenever xpi = ypi (recall
that the first k features of x are flipped at Line 6), or change
the feature fk+1 (i.e., yk+1 = xk+1 ) whenever xpi = ypi .
Roughly speaking, the so-obtained feature fj minimally con-
tributes to determine the value M(y) and keeps the distance
equal to k. Finally, if there exist no other semifactual z for x
s.t. z ⇥ y, then y is returned at Line 13.
Example 7. Consider the model M = step(x · [⇥2, 2, 0] +
1) of Example 1, the instance x = [0, 1, 1] and the linear
preference f1 f2 . We have that s = [f1 /2, f2 /2, f3 /0],
s⇥ = [f3 /0, f2 /2, f1 /2] and k = 2. Thus y = [0, 0, 0] with
⌅ = 3. As y2 = 1 and x2 = y2 , Algorithm 1 returns z =
flip(y, [2, j]) = [1, 1, 0] with j = q3 = 1 and ⌅ = 1.
We now present Algorithm 2 for the FBDD model.
It starts by creating a copy M⇥ of M where edge labels, as-
signed by function E , represent boolean values correspond-
ing to whether or not the edge is in line with x. Formally,
E (u, v) = 1 if x V (u) = E (u, v); 0 otherwise. Intuitively,
let ⇧ be a path in M from root t to leaf nodes representing
M(x) (i.e., to ⌅ if M(x) = 1, ⇧ otherwise), and let w be
the weight of ⇧ computed as the sum of (boolean) weights on
the edges of ⇧. By following the path ⇧, it is possible to build
a semifactual for x of distance n ⇥ w. To this end, at Line 2
a graph N isomorphic to M⇥ w.r.t. V , is built with function
subgraph by keeping all the paths in M⇥ ending in M (x)
and having minimum weight. All such paths are stored in ⇥
at Line 3. Then, the algorithm checks if it is possible to build
a semifactual y for x satisfying fp1 , otherwise fp2 , and so on.
Particularly, assuming to be at step fpi for some fpi in ⇤, if
there exists a path ⇧ ⇤ ⇥ and the feature fpi can be set to 1 in
y (that is the condition of Line 5) then a best semifactual y of
x is obtained from x by flipping every features i of x not ap-
pearing in ⇧ (i.e., V (u) = i for any node u in ⇧) or differing
in the assignment given by ⇧ (i.e., there is no edge (u, v) ⇤ ⇧
s.t. V (u) = i and E (u, v) = 0). More formally, the func-
tion build(x, ⇧) returns the instance y = flip(x, {i ⇤ [1, n] |
(u, v) ⇤ ⇧ such that V (u)=i and E (u, v)=1}). Finally, if
the algorithm does not return a semifactual at Line 6, then at
Line 8 it returns a semifactual y of x that satisfies none of the
fpi s, obtained from x through function build(x, ⇧) where ⇧
is a path taken non-deterministically from ⇥.
Example 8. Consider the FBDD M = (V, E, V , E ) in
Figure 2(left) for the mortgage scenario of Example 1. Let
x = [0, 1, 1] and ⇤ = f2 f1 . For each edge (u, v) ⇤
E, Figure 2(center) shows the value E (u, v) (computed at
Line 1), while Figure 2(right) shows the graph N obtained
by removing all the paths ⇧ of M⇥ whose sum of weights is
greater than w = 1. This means that semifactuals y of x are
at distance d(x, y) = n ⇥ w = 2. As there exists in N the
path ⇧ : (u, u⇥ ), (u⇥ , u⇥⇥ ) where V (u) = 3, V (u⇥ ) = 2,
V (u ) = ⌅, and E (u , u ) = 1 then it is possible to get
⇥⇥ ⇥ ⇥⇥
a semifactual y from x with x2 = 1. In fact, Algorithm 2
returns y=build(x, ⇧)=flip(x, {1, 3})=[1, 1, 0] at Line 6.
As stated next, the two algorithms are sound, complete and
return best semifactuals in PTIME.
Theorem 6. Algorithms 1 and 2 are sound, complete, and
run in polynomial-time.
Clearly, the proposed algorithms also work when no pref-
erences are available, that is when = ✓, returning a generic

Algorithm 2 Computing a (best) semifactual for FBDDs
Input: FBDD M = (V, E, V , E ) with root t, instance x ⇤
{0, 1}n , and linear preference ⇤ = fp1 · · · fpl .
Output: A best semifactual y for x w.r.t. M and ⇤.
1: Let M =(V =V, E =E,
⇥ ⇥ ⇥
V = V , E ) be a copy of M,
where E (u, v)=1 if(x V (u) = E (u, v)), 0 otherwise;
2: Let N = subgraph(M⇥ , M(x));
3: Let ⇥ be the set of paths in N from t to leaf nodes;
4: for fpi ⇤ {fp1 , . . . , fpl } do
5: if ⌦⇧ ⇤ ⇥ with y = build(x, ⇧) and ypi = 1
6: return y;
7: Let ⇧ be a path of ⇥ taken non-deterministically;
8: return y = build(x, ⇧);
semifactual at maximum distance. Providing a PTIME algo-
rithm returning a best semifactual for MLPs is unfeasible, as
backed by our complexity analysis. However, as an heuristic,
we could adapt Algorithm 1 so that the scores si s encode fea-
ture importance, similarly to what is done in [Ramon et al.,
2020]—we plan to explore this direction in future work.
Observed that, although the number of (best) semifactu-
als⇤is⌅potentially exponential w.r.t. the number of features (it
is nk where k represents the maximum number of features
changed in x to obtain semifactuals), Algorithms 1 and 2 can
be exploited to obtain a finite representation of all semifac-
tuals. For instance, all semifactuals of x in Algorithm 2 are
those obtained from x by considering all paths in ⇧ ⇤ ⇥, that
is the set {build(x, ⇧) such that ⇧ ⇤ ⇥}.
Finally, it is important to note that both Algorithms 1 and
2 can be easily adapted to deal with (best) counterfactual ex-
planations, as shown in the Supplementary Material.
5 Related Work
Looking for transparent and interpretable models has led to
the exploration of several explanation paradigms in eXplain-
able AI (XAI). Factual explanations [Ciravegna et al., 2020;
Guidotti et al., 2018; Bodria et al., 2023; Wang et al., 2021;
Ciravegna et al., 2023] elucidate the inner workings of AI
models by delineating why a certain prediction was made
based on the input data. Counterfactual explanations [Der-
vakos et al., 2023; Romashov et al., 2022; Albini et al., 2020;
Wu et al., 2019; Guidotti, 2022], delve into hypothetical sce-
narios, revealing alternative input configurations that could
have resulted in a different prediction. These explanations
offer insights into the model’s decision boundaries and aid in
understanding its behavior under varied circumstances. Semi-
factual explanations [Dandl et al., 2023; Aryal and Keane,
2023; Kenny and Keane, 2021] bridge the gap between fac-
tual and counterfactual realms by presenting feasible alter-
ations to the input data that do not change a decision out-
come. This trichotomy of explanation types contributes sig-
nificantly to the holistic comprehension and trustworthiness
of AI systems, catering to various stakeholders’ needs for
transparency and interpretability. Most existing works on
XAI focus on proposing novel methods for generating expla-
t t t
0 3 1 0 3 1 3
2
0 2 1 0 1 1 0 2 1 1 1 0
1
0 1 2 1
1 1 2 1
1 0 0 0
⇥ ⇥
Figure 2: (Left) FBDD model M = (V, E, V , E ) of Exam-
ple 8 with root t and V (t) = 3. (Center) FBDD model M =
(V , E , V , E ) computed at Line 1 of Algorithm 2. (Right)
Graph N obtained at Line 2 of Algorithm 2. Squared nodes rep-
resent leaf nodes (⌅ for M(·) = 1, and ⇧ for M(·) = 0).
nations, with few addressing the computational complexity
of related problems [Barceló et al., 2020; Arenas et al., 2022;
Arenas et al., 2021; Eiben et al., 2023; El Harzli et al., 2023;
Marzari et al., 2023; Ordyniak et al., 2023]. However, none
of these works specifically focuses on semifactuals.
As discussed earlier, several approaches have been pro-
posed to handle preferences in AI. In the context of logic
programming there has been extensive research on prefer-
ences among rules [Brewka, 1989; Brewka and Eiter, 1999;
Delgrande et al., 2003; Eiter et al., 2003; Schaub and Wang,
2001] and among atoms or their combinations [Sakama
and Inoue, 2000; Brewka et al., 2003; Greco et al., 2007;
Brewka et al., 2015]. Related to this, conditional prefer-
ence networks [Boutilier et al., 2004; Rossi et al., 2004]
offer an alternative formalism that allows to express sets of
conditional ceteris paribus (i.e. all else being equal) prefer-
ence statements [Allen et al., 2017; Goldsmith et al., 2008;
Lukasiewicz and Malizia, 2019].
6 Conclusions and Future Works
In this paper, after exploring local post-hoc interpretability
queries related to semifactuals and their computational com-
plexity among three classes of models (FBDDs, perceptrons,
and MLPs), we introduced a framework that enables users
to personalize semifactual and counterfactual explanations
based on preferences. Then, we investigated the complexity
of the proposed framework and presented PTIME algorithms.
Our approach to handle preferences over semifac-
tual/counterfactual explanations is inspired by the Answer Set
Optimization approach [Brewka et al., 2003]. In particular,
conditional preferences among features are defined by means
of preference rules, the satisfaction of each rule is evaluated
quantitatively, whereas the overall preference order is defined
in a qualitative way. The main advantages of such approach
consist in the simplicity and compactness of representation,
and combination of quantitative and qualitative evaluations.
As future work, we plan to explore additional interpretabil-
ity queries, particularly focusing on counting problems like
quantifying the number of semifactuals/counterfactuals for
specific input instances, aiming to enhance the evaluation of
interpretability across the three classes of models. Further-
more, we aim to extend our research by investigating more
inclusive model formats, specifically those accommodating
real-number inputs and non-binary discrete features, thereby
expanding the breadth of our analysis.
References
[Albini et al., 2020] Emanuele Albini, Antonio Rago, Pietro
Baroni, and Francesca Toni. Relation-based counterfactual
explanations for bayesian network classifiers. In Proceed-
ings of International Joint Conference on Artificial Intelli-
gence (IJCAI), pages 451–457, 2020.
[Allen et al., 2017] Thomas E. Allen, Judy Goldsmith, Hay-
den Elizabeth Justice, Nicholas Mattei, and Kayla Raines.
Uniform random generation and dominance testing for cp-
nets. Journal of Artificial Intelligence Research, 59:771–
813, 2017.
[Arenas et al., 2021] Marcelo Arenas, Daniel Baez, Pablo
Barceló, Jorge Pérez, and Bernardo Subercaseaux. Foun-
dations of symbolic languages for model interpretability.
Proceedings of Advances in Neural Information Process-
ing Systems, 34:11690–11701, 2021.
[Arenas et al., 2022] Marcelo Arenas, Pablo Barceló,
Miguel Romero Orth, and Bernardo Subercaseaux.
On computing probabilistic explanations for decision
trees. Proceedings of Advances in Neural Information
Processing Systems, 35:28695–28707, 2022.
[Aryal and Keane, 2023] Saugat Aryal and Mark T. Keane.
Even if explanations: Prior work, desiderata & bench-
marks for semi-factual xai. In Proceedings of Interna-
tional Joint Conference on Artificial Intelligence (IJCAI),
pages 6526–6535, 2023.
[Bakker et al., 2022] Michiel Bakker, Martin Chadwick,
Hannah Sheahan, Michael Tessler, Lucy Campbell-
Gillingham, Jan Balaguer, Nat McAleese, Amelia Glaese,
John Aslanides, Matt Botvinick, et al. Fine-tuning lan-
guage models to find agreement among humans with di-
verse preferences. Proceedings of Advances in Neural In-
formation Processing Systems, 35:38176–38189, 2022.
[Barceló et al., 2020] Pablo Barceló, Mikaël Monet, Jorge
Pérez, and Bernardo Subercaseaux. Model interpretabil-
ity through the lens of computational complexity. In Pro-
ceedings of Advances in Neural Information Processing
Systems, 2020.
[Bodria et al., 2023] Francesco Bodria, Fosca Giannotti,
Riccardo Guidotti, Francesca Naretto, Dino Pedreschi, and
Salvatore Rinzivillo. Benchmarking and survey of expla-
nation methods for black box models. Data Mining and
Knowledge Discovery, pages 1–60, 2023.
[Boutilier et al., 2004] Craig Boutilier, Ronen I. Brafman,
Carmel Domshlak, Holger H. Hoos, and David Poole. Cp-
nets: A tool for representing and reasoning with condi-
tional ceteris paribus preference statements. Journal of
Artificial Intelligence Research, 21:135–191, 2004.
[Brafman and Domshlak, 2009] Ronen I. Brafman and
Carmel Domshlak. Preference handling - an introductory
tutorial. AI Mag., 30(1):58–86, 2009.
[Brewka and Eiter, 1999] Gerhard Brewka and Thomas
Eiter. Preferred answer sets for extended logic programs.
Artificial Intelligence, 109(1-2):297–356, 1999.
[Brewka et al., 2003] Gerhard Brewka, Ilkka Niemelä, and
Miroslaw Truszczynski. Answer set optimization. In Pro-
ceedings of International Joint Conference on Artificial In-
telligence (IJCAI), pages 867–872, 2003.
[Brewka et al., 2015] Gerhard Brewka, James P. Delgrande,
Javier Romero, and Torsten Schaub. asprin: Customizing
answer set preferences without a headache. In Proceedings
of AAAI Conference on Artificial Intelligence, pages 1467–
1474, 2015.
[Brewka, 1989] Gerhard Brewka. Preferred subtheories: An
extended logical framework for default reasoning. In Pro-
ceedings of International Joint Conference on Artificial In-
telligence (IJCAI), pages 1043–1048, 1989.
[Ciravegna et al., 2020] Gabriele Ciravegna, Francesco Gi-
annini, Marco Gori, Marco Maggini, and Stefano Melacci.
Human-driven fol explanations of deep learning. In Pro-
ceedings of International Joint Conference on Artificial In-
telligence (IJCAI), pages 2234–2240, 2020.
[Ciravegna et al., 2023] Gabriele Ciravegna, Pietro Barbi-
ero, Francesco Giannini, Marco Gori, Pietro Lió, Marco
Maggini, and Stefano Melacci. Logic explained networks.
Artificial Intelligence, 314:103822, 2023.
[Dandl et al., 2023] Susanne Dandl, Giuseppe Casalicchio,
Bernd Bischl, and Ludwig Bothmann. Interpretable re-
gional descriptors: Hyperbox-based local explanations. In
Proceedings of Machine Learning and Knowledge Dis-
covery in Databases, volume 14171, pages 479–495.
Springer, 2023.
[Delgrande et al., 2003] James P. Delgrande, Torsten
Schaub, and Hans Tompits. A framework for compiling
preferences in logic programs. Theory and Practice of
Logic Programming, 3(2):129–187, 2003.
[Dervakos et al., 2023] Edmund Dervakos, Konstantinos
Thomas, Giorgos Filandrianos, and Giorgos Stamou.
Choose your data wisely: A framework for semantic
counterfactuals. arXiv preprint arXiv:2305.17667, 2023.
[Eiben et al., 2023] Eduard Eiben, Sebastian Ordyniak, Gia-
como Paesani, and Stefan Szeider. Learning small decision
trees with large domain. In Proceedings of International
Joint Conference on Artificial Intelligence (IJCAI), pages
3184–3192, 2023.
[Eiter et al., 2003] Thomas Eiter, Wolfgang Faber, Nicola
Leone, and Gerald Pfeifer. Computing preferred answer
sets by meta-interpretation in answer set programming.
Theory and Practice of Logic Programming, 3(4-5):463–
498, 2003.
[El Harzli et al., 2023] Ouns El Harzli, Bernardo Cuenca
Grau, and Ian Horrocks. Cardinality-minimal explanations
for monotonic neural networks. In Proceedings of Interna-
tional Joint Conference on Artificial Intelligence (IJCAI),
pages 3677–3685, 2023.
[Goldsmith et al., 2008] Judy Goldsmith, Jérôme Lang,
Miroslaw Truszczynski, and Nic Wilson. The compu-
tational complexity of dominance and consistency in cp-
nets. Journal of Artificial Intelligence Research, 33:403–
432, 2008.
[Greco et al., 2007] Sergio Greco, Irina Trubitsyna, and Es-
ter Zumpano. On the semantics of logic programs with
preferences. Journal of Artificial Intelligence Research,
30:501–523, 2007.
[Guidotti et al., 2018] Riccardo Guidotti, Anna Monreale,
Salvatore Ruggieri, Franco Turini, Fosca Giannotti, and
Dino Pedreschi. A survey of methods for explaining black
box models. ACM computing surveys (CSUR), 51(5):1–42,
2018.
[Guidotti, 2022] Riccardo Guidotti. Counterfactual explana-
tions and how to find them: literature review and bench-
marking. Data Mining and Knowledge Discovery, pages
1–55, 2022.
[Kahneman and Tversky, 1981] Daniel Kahneman and
Amos Tversky. The simulation heuristic. National
Technical Information Service, 1981.
[Kapoor et al., 2012] Ashish Kapoor, Bongshin Lee, Desney
Tan, and Eric Horvitz. Performance and preferences: In-
teractive refinement of machine learning procedures. In
Proceedings of AAAI Conference on Artificial Intelligence,
pages 1578–1584, 2012.
[Kenny and Huang, 2023] Eoin M. Kenny and Weipeng
Huang. The utility of “even if” semi-factual explanation
to optimise positive outcomes. In Thirty-seventh Confer-
ence on Neural Information Processing Systems, 2023.
[Kenny and Keane, 2021] Eoin M Kenny and Mark T Keane.
On generating plausible counterfactual and semi-factual
explanations for deep learning. In Proceedings of AAAI
Conference on Artificial Intelligence, pages 11575–11585,
2021.
[Lukasiewicz and Malizia, 2019] Thomas Lukasiewicz and
Enrico Malizia. Complexity results for preference aggre-
gation over (m)cp-nets: Pareto and majority voting. Artifi-
cial Intelligence, 272:101–142, 2019.
[Marzari et al., 2023] Luca Marzari, Davide Corsi, Ferdi-
nando Cicalese, and Alessandro Farinelli. The #dnn-
verification problem: Counting unsafe inputs for deep neu-
ral networks. In Proceedings of International Joint Con-
ference on Artificial Intelligence (IJCAI), pages 217–224,
2023.
[McCloy and Byrne, 2002] Rachel McCloy and Ruth MJ
Byrne. Semifactual “even if” thinking. Thinking & rea-
soning, 8:41–67, 2002.
[Ordyniak et al., 2023] S Ordyniak, G Paesani, and S Szei-
der. The parameterized complexity of finding concise lo-
cal explanations. In Proceedings of International Joint
Conference on Artificial Intelligence (IJCAI), pages 3312–
3320, 2023.
[Papadimitriou, 1994] Christos H. Papadimitriou. Computa-
tional complexity. Addison-Wesley, 1994.
[Ramon et al., 2020] Yanou Ramon, David Martens, Fos-
ter Provost, and Theodoros Evgeniou. A comparison of
instance-level counterfactual explanation algorithms for
behavioral and textual data: Sedc, lime-c and shap-c. Ad-
vances in Data Analysis and Classification, 14:801–819,
2020.
[Romashov et al., 2022] Piotr Romashov, Martin Gjoreski,
Kacper Sokol, Maria Vanina Martinez, and Marc
Langheinrich. Baycon: Model-agnostic bayesian counter-
factual generator. In Proceedings of International Joint
Conference on Artificial Intelligence (IJCAI), pages 23–
29, 2022.
[Rossi et al., 2004] Francesca Rossi, Kristen Brent Venable,
and Toby Walsh. mcp nets: Representing and reasoning
with preferences of multiple agents. In Proceedings of the
Nineteenth National Conference on Artificial Intelligence,
Sixteenth Conference on Innovative Applications of Artifi-
cial Intelligence, pages 729–734, 2004.
[Rossi et al., 2011] Francesca Rossi, Kristen Brent Venable,
and Toby Walsh. A Short Introduction to Preferences: Be-
tween Artificial Intelligence and Social Choice. Synthesis
Lectures on Artificial Intelligence and Machine Learning.
Morgan & Claypool Publishers, 2011.
[Sakama and Inoue, 2000] Chiaki Sakama and Katsumi In-
oue. Prioritized logic programming and its application to
commonsense reasoning. Artificial Intelligence, 123(1-2),
2000.
[Santhanam et al., 2016] Ganesh Ram Santhanam, Samik
Basu, and Vasant G. Honavar. Representing and Reason-
ing with Qualitative Preferences: Tools and Applications.
Synthesis Lectures on Artificial Intelligence and Machine
Learning. Morgan & Claypool Publishers, 2016.
[Schaub and Wang, 2001] Torsten Schaub and Kewen Wang.
A comparative study of logic programs with preference.
In Proceedings of International Joint Conference on Arti-
ficial Intelligence (IJCAI), pages 597–602, 2001.
[Wang et al., 2021] Eric Wang, Pasha Khosravi, and
Guy Van den Broeck. Probabilistic sufficient explana-
tions. In Proceedings of International Joint Conference
on Artificial Intelligence (IJCAI), pages 3082–3088, 2021.
[Wegener, 2004] Ingo Wegener. Bdds—design, analysis,
complexity, and applications. Discrete Applied Mathemat-
ics, 138(1):229–251, 2004.
[Wu et al., 2019] Yongkai Wu, Lu Zhang, and Xintao Wu.
Counterfactual fairness: Unidentification, bound and al-
gorithm. In Proceedings of International Joint Conference
on Artificial Intelligence (IJCAI), pages 1438–1444, 2019.
[Zhu et al., 2022] Yongchun Zhu, Zhenwei Tang, Yudan Liu,
Fuzhen Zhuang, Ruobing Xie, Xu Zhang, Leyu Lin, and
Qing He. Personalized transfer of user preferences for
cross-domain recommendation. In Proceedings of the Fif-
teenth ACM International Conference on Web Search and
Data Mining, pages 1507–1515, 2022.