P2C: Path to Counterfactuals

TL;DR

P2C introduces a causal, sequential planning framework for generating realistic, actionable counterfactual explanations in high-stakes decision-making, addressing limitations of existing methods by modeling causal dependencies and feasible intervention sequences.

Contribution

The paper presents P2C, a novel, model-agnostic approach that produces causally consistent, sequential plans for counterfactual explanations, incorporating causal dependencies and realistic intervention sequences.

Findings

P2C outperforms standard planners in generating legal, feasible plans.

P2C provides more realistic cost estimates by focusing on user-initiated changes.

The framework effectively models causal relationships and sequential interventions.

Abstract

Machine-learning models are increasingly driving decisions in high-stakes settings, such as finance, law, and hiring, thus, highlighting the need for transparency. However, the key challenge is to balance transparency -- clarifying `why' a decision was made -- with recourse: providing actionable steps on `how' to achieve a favourable outcome from an unfavourable outcome. Counterfactual explanations reveal `why' an undesired outcome occurred and `how' to reverse it through targeted feature changes (interventions). Current counterfactual approaches have limitations: 1) they often ignore causal dependencies between features, and 2) they typically assume all interventions can happen simultaneously, an unrealistic assumption in practical scenarios where actions are typically taken in a sequence. As a result, these counterfactuals are often not achievable in the real world. We present P2C (Path-to-Counterfactuals), a model-agnostic framework that produces a plan (ordered sequence of actions) converting an unfavourable outcome to a causally consistent favourable outcome. P2C addresses both limitations by 1) Explicitly modelling causal relationships between features and 2) Ensuring that each intermediate state in the plan is feasible and causally valid. P2C uses the goal-directed Answer Set Programming system s(CASP) to generate the plan accounting for feature changes that happen automatically due to causal dependencies. Furthermore, P2C refines cost (effort) computation by only counting changes actively made by the user, resulting in realistic cost estimates. Finally, P2C highlights how its causal planner outperforms standard planners, which lack causal knowledge and thus can generate illegal actions.

Tables

Table 1. Table 1: Time to generate a counterfactual reduces as Search Space Size decreases

Dataset	Search Space Size	Avg. Time to cf (ms)	Reduced Search Space Size	Avg. Time to cf (ms)
Adult	11,225,088	185.53	6,414,336	107.57
German	13,200	262.34	2,640	74.11
Cars	1728	1.963	432	1.878

Table 2. Table 2: Comparison of Nearest and Furthest Counterfactuals for C3G and P2C

Dataset	Model	K = 20
		Metric Used to Sort the Closest
		L1			L2			L0
		Nearest	Furthest	Avg.	Nearest	Furthest	Avg.	Nearest	Furthest	Avg.
Adult	C3G	1.012	1.470	1.296	1.012	1.221	1.113	1	1	1
	P2C	0.701	1.031	0.907	0.701	0.903	0.829	1	1	1
German	C3G	3.3342	3.3415	3.3378	1.76399	1.76401	1.7640	4	4	4
	P2C	2.3342	2.3415	2.3379	1.45316	1.45318	1.45317	3	3	3
Cars	C3G	1	3	2.3	1	1.732	1.499	1	3	2.3
	P2C	1	3	2.3	1	1.732	1.499	1	3	2.3

Table 3. Table 3: Performance of P2C against counterfactual based methods

Dataset	Model	Causally Compliant	Cf Causal Consistency (%)	Path contains only legal actions
Adult	Borderline-CF	FALSE	30	FALSE
	DiCE	Indirectly	80	FALSE
	MACE	FALSE	80	FALSE
	MINT	TRUE	100	FALSE
	C3G	TRUE	100	FALSE
	P2C	TRUE	100	TRUE
German	Borderline-CF	FALSE	80	FALSE
	DiCE	Indirectly	80	FALSE
	MACE	FALSE	20	FALSE
	MINT	TRUE	100	FALSE
	C3G	TRUE	100	FALSE
	P2C	TRUE	100	TRUE
Car	Borderline-CF	FALSE	N/A	TRUE
	DiCE	Indirectly	N/A	TRUE
	MACE	FALSE	N/A	TRUE
	MINT	TRUE	N/A	TRUE
	C3G	TRUE	N/A	TRUE
	P2C	TRUE	N/A	TRUE

Table 4. Table 4: Performance on Adult , German Credit and Car Evaluation Datasets

Dataset	Model	Fid. (%)	Acc. (%)	Prec. (%)	Rec. (%)	F1 (%)
Adult	DNN	N/A	85.57$\pm$0.38	85.0$\pm$0.63	85.8$\pm$0.40	85.0$\pm$0.63
	FOLD-SE[DNN]	93.16$\pm$0.60	84.2$\pm$0.28	83.4$\pm$0.49	84.2$\pm$0.40	83.4$\pm$0.49
	GBC	N/A	86.45$\pm$0.33	85.8$\pm$0.40	86.6$\pm$0.49	85.8$\pm$0.40
	FOLD-SE[GBC]	95.94$\pm$0.67	85.24$\pm$0.23	84.6$\pm$0.49	85.2$\pm$0.40	84.2$\pm$0.40
	RF	N/A	85.60$\pm$0.27	85.0$\pm$0.00	85.6$\pm$0.49	85.2$\pm$0.40
	FOLD-SE[RF]	90.27$\pm$0.30	84.37$\pm$0.23	83.4$\pm$0.49	84.4$\pm$0.49	83.2$\pm$0.40
	LR	N/A	84.78$\pm$0.28	84.2$\pm$0.40	84.8$\pm$0.40	84.2$\pm$0.40
	FOLD-SE[LR]	94.03$\pm$0.36	83.92$\pm$0.32	83.0$\pm$0.00	83.8$\pm$0.40	83.4$\pm$0.49
German	DNN	N/A	74.5$\pm$1.67	73.0$\pm$2.19	74.4$\pm$1.74	73.0$\pm$2.19
	FOLD-SE[DNN]	81.5$\pm$2.32	71.6$\pm$1.50	71.0$\pm$2.37	71.6$\pm$1.50	70.8$\pm$1.72
	GBC	N/A	75.8$\pm$1.63	74.6$\pm$1.62	76.0$\pm$1.67	74.6$\pm$1.62
	FOLD-SE[GBC]	81.6$\pm$5.42	72.6$\pm$3.64	72.0$\pm$2.90	72.6$\pm$3.61	71.0$\pm$3.03
	RF	N/A	75.7$\pm$1.21	74.6$\pm$2.15	76.0$\pm$1.41	72.8$\pm$1.17
	FOLD-SE[RF]	85.1$\pm$2.37	71.6$\pm$0.20	70.2$\pm$1.94	71.2$\pm$0.40	66.2$\pm$2.86
	LR	N/A	74.5$\pm$1.18	73.0$\pm$1.26	74.6$\pm$1.36	73.4$\pm$1.02
	FOLD-SE[LR]	82.5$\pm$2.41	72.2$\pm$2.01	71.4$\pm$2.87	72.0$\pm$2.19	71.8$\pm$2.48
Car	DNN	N/A	94.4$\pm$0.31	97.6$\pm$0.49	97.2$\pm$0.40	97.2$\pm$0.40
	FOLD-SE[DNN]	91.55$\pm$3.95	91.6$\pm$4.00	93.6$\pm$2.50	91.6$\pm$3.88	91.8$\pm$3.87
	GBC	N/A	97.5$\pm$1.12	97.4$\pm$1.02	97.4$\pm$1.02	97.4$\pm$1.02
	FOLD-SE[GBC]	97.16$\pm$3.80	95.24$\pm$4.30	96.4$\pm$2.80	95.4$\pm$4.27	95.4$\pm$4.27
	RF	N/A	95.71$\pm$0.56	95.6$\pm$0.80	95.6$\pm$0.80	95.6$\pm$0.80
	FOLD-SE[RF]	94.27$\pm$3.27	95.08$\pm$2.92	96.0$\pm$2.19	95.2$\pm$3.12	95.4$\pm$2.87
	LR	N/A	94.79$\pm$1.43	95.0$\pm$1.79	94.8$\pm$1.72	94.8$\pm$1.72
	FOLD-SE[LR]	95.37$\pm$1.21	94.32$\pm$1.54	94.8$\pm$1.17	94.4$\pm$1.50	94.4$\pm$1.50

Equations

$$s\in SwhereS=\{(V_1,V_2,...,V_n)|V_i\in D_i,foreachiin1,...,n\}$$

$${\theta }_C(S^{\prime })=\{s\in S^{\prime }\mid ssatisfiesallcausalrulesinC\}$$

$$S_C={\theta }_C(S)$$

$${\theta }_Q(S^{\prime })=\{s\in S^{\prime }\mid ssatisfiesanydecisionruleinQ\}$$

$$S_Q={\theta }_Q(S_C)={\theta }_Q({\theta }_C(S))$$

$$i\in S_C$$

$$a:S\to S\mid wherea\in A$$

$$\delta(s,a)=\left\{\begin{array}[]{l}a(s)\textit{ if }a(s)\in S_{C}\\ \delta(a(s),a^{\prime})\textit{ with }a\in A,a^{\prime}\in A\textit{, otherwise}\end{array}\right.$$

$$s_0,s_1,\dots ,s_m\text{where}{s}_j\in S_C\text{for all}j\in \{0,\dots ,m\},$$

$$suchthat{s}_0=I;s_m=G;s_0,...,s_{m-1}\notin G;s_{i+1}\in \delta (s_i)\text{for}i\in \{0,\dots ,m-1\}$$

$$is\_counterfactual(s,C,Q)=TRUE\mid sagreeswithC;sdisagreeswithQ;$$

$$\mathcal{X}=X_1\times X_2\times \cdots \times X_N.$$

$${\mathcal{X}}^{\prime }=X_1^{\prime }\times X_2^{\prime }\times \cdots \times X_N^{\prime }.$$

$$S_k\subseteq {\mathcal{X}}^{\prime }.$$

$$|x_j^{(m)}-q_j|<|x_j-q_j|\text{for all }m=1,\dots ,k.$$

$$x_i^{\prime }=\{\begin{array}{ll}{x}_i,& i\notin J\\ x_i^{(m_i)},& i\in J\end{array}\text{with }{x}_i^{(m_i)}\in X_i^{\prime }\text{ and }|x_i^{(m_i)}-q_i|<|x_i-q_i|.$$

$$d_1({\mathbf{x}}^{\prime },\mathbf{q})=\sum _{i=1}^N|x_i^{\prime }-q_i|=\sum _{i\notin J}|x_i-q_i|+\sum _{i\in J}|x_i^{(m_i)}-q_i|<\sum _{i\notin J}|x_i-q_i|+\sum _{i\in J}|x_i-q_i|=d_1(\mathbf{x},\mathbf{q}).$$

$$d_2({\mathbf{x}}^{\prime },\mathbf{q})=\sqrt{\sum _{i=1}^N(x_i^{\prime }-q_i{)}^2}=\sqrt{\sum _{i\notin J}(x_i-q_i{)}^2+\sum _{i\in J}(x_i^{(m_i)}-q_i{)}^2}<$$

$$\sqrt{\sum _{i\notin J}(x_i-q_i{)}^2+\sum _{i\in J}(x_i-q_i{)}^2}=d_2(\mathbf{x},\mathbf{q}).$$

$$d_0(\mathbf{x},\mathbf{q})=\sum _{i=1}^N{1}_{x_i\ne q_i}.$$

$$x_i^{\prime }=\{\begin{array}{ll}{x}_i^{(m_i)},& i\in J\\ x_i,& i\notin J\end{array}\text{with }{x}_i^{(m_i)}\in X_i^{\prime }.$$

$$d_0({\mathbf{x}}^{\prime },\mathbf{q})\le d_0(\mathbf{x},\mathbf{q})$$

$$S_k\subseteq {\mathcal{X}}^{\prime }.$$

$$G=\{s\in S_C|s\notin S_Q\}$$

Full text

Current counterfactual approaches have limitations: 1) they often ignore causal dependencies between features, and 2) they typically assume all interventions can happen simultaneously, an unrealistic assumption in practical scenarios where actions are typically taken in a sequence. As a result, these counterfactuals are often not achievable in the real world.

We present P2C (Path-to-Counterfactuals), a model-agnostic framework that produces a plan (ordered sequence of actions) converting an unfavourable outcome to a causally consistent favourable outcome. P2C addresses both limitations by 1) Explicitly modelling causal relationships between features and 2) Ensuring that each intermediate state in the plan is feasible and causally valid. P2C uses the goal-directed Answer Set Programming system s(CASP) to generate the plan accounting for feature changes that happen automatically due to causal dependencies. Furthermore, P2C refines cost (effort) computation by only counting changes actively made by the user, resulting in realistic cost estimates. Finally, P2C highlights how its causal planner outperforms standard planners, which lack causal knowledge and thus can generate illegal actions.

1 Introduction

Machine Learning systems are increasingly entrusted with high-stakes decision-making tasks, ranging from job candidate screening to loan approvals. Yet their opaque, “black-box” nature makes it difficult for affected individuals to understand why a particular decision was reached, especially when the outcome is undesired or unfavourable. Additionally, beyond mere explanations, people often want to know how they could flip a negative outcome (e.g., loan denied) into a positive one (loan approved). A solution to the above problems has been provided by counterfactuals explanations. Counterfactuals explain not only ‘why’ a decision outcome was made but also ‘how’ to achieve a desired outcome by specifying the necessary feature changes, i.e., interventions. However, current counterfactual approaches have limitations: (1) they often ignore causal dependencies between features, and/or (2) they typically assume that all feature changes can happen simultaneously—an unrealistic assumption in practical scenarios where actions are typically taken in a sequence.

We introduce P2C (Path to Counterfactuals), a model-agnostic framework that automatically generates a sequential path to a minimum cost causally compliant counterfactual explanation for any classifier—–statistical or rule-based. P2C follows the given steps:

1. Rule Learning: Extracts interpretable decision rules from the underlying black box model and causal rules from data if the causal model is not provided. Optional: If the causal model is not provided, Expert Verification is used to ensure learned causal dependencies from Step 1 reflect true causation, not spurious correlations.
2. Using the decision and causal rules, it obtains the minimum effort counterfactual $g$ that is causally consistent.
3. Uses Goal-Directed ASP system, s(CASP), to treat counterfactual search as a planning problem, by finding a step-by-step path of allowable feature changes from the initial (negative) state $i$ to the counterfactual/ goal (positive) state $g$.

In P2C, the initial state $i$ satisfies the underlying classifier’s reject-condition (e.g., ‘?- reject_loan(john)’ succeeds), while any goal state $g\in G$ must flip that decision (e.g., ‘?- not reject_loan(john)’ succeeds). Finding a path from $i$ to $g$ becomes an ASP-driven planning task in which every direct action (direct change of a feature value) and causal action (downstream causal changes triggered due to preceding direct action) respects causal dependencies between features. For instance, one cannot directly alter the credit score. In order to increase the credit score one must first clear debt: P2C encodes that “$no\_debt\rightarrow credit\_score\geq 620$”. This leads to a direct action of clearing debt having the causal effect of increasing the credit_score to ‘$\geq$ 620’.

Unlike current counterfactual approaches that either ignore causal constraints or return an unordered set of actions, P2C provides an ordered step-by-step series of actions/interventions (direct or causal) to the counterfactual state by leveraging s(CASP)’s [1] native backtracking and compact FOLD-SE [20] rule sets. Additionally, P2C produces paths guaranteed to contain only legal actions (does not directly alter credit_score), unlike that of a standard planner, which will take illegal actions due to lack of causal knowledge. In the next section, we review related work before detailing the P2C methodology.

2 Background and Related Work

2.1 Counterfactual Reasoning

Explanations help in understanding decisions. Counterfactuals [19] were used to explain individual decisions by offering insights on achieving the desired outcomes. For instance, a counterfactual explanation for a loan denial might state: If John had good credit, his loan application would be approved. This involves imagining alternate (reasonably plausible) scenarios where the desired outcome is achievable. For a binary classifier given by $f:X\rightarrow\{0,1\}$, we define a set of counterfactual explanations $\hat{x}$ for a factual input $x\in X$ as $\textit{CF}_{f}(x)=\{\hat{x}\in X|f(x)\neq f(\hat{x})\}$. This set includes all inputs $\hat{x}$ leading to different predictions than the original input $x$ under $f$. Various counterfactual methods [4], [18], [10], [17], [15] were proposed, however, they assumed feature independence. This resulted in unrealistic counterfactuals as in the real world, causal dependencies exist between features.

2.2 Causality and Counterfactuals

Causality relates to the cause-effect relationship among variables, where one event (the cause) directly influences another event (the effect). In the causal framework [14], causality is defined through interventions. An intervention involves external manipulation of $P$, which explicitly changes $P$ and measures the effect on $Q$. This mechanism is formalized using Structural Causal Models (SCMs), which represent the direct impact of $P$ on $Q$. SCMs allow us to establish causality by demonstrating that an intervention on $P$ leads to a change in $Q$. In SCM-based counterfactual approaches such as MINT [11], capturing the downstream effects of interventions is essential to ensure causally consistent counterfactuals. However this is challenging: real-world domains often contain feedback (e.g., low credit score $\rightarrow$ high debt $\rightarrow$ even lower credit score) and context-dependent effects that are difficult to capture with the acyclic graphs underpinning most DAG-based SCMs.

By explicitly modelling counterfactual dependencies, SCMs help in generating counterfactuals. While MINT produces causally consistent counterfactuals, it typically proposes a simultaneous set of minimal interventions/actions. When applied together, this set of interventions produces the counterfactual solution. However, executing such a set of simultaneous interventions in the real world might not be possible. The order matters as some interventions may depend on others or require different time-frames to implement. Sequence planning is necessary to account for such causal dependencies and practical constraints. C3G [7], a counterfactual approach, also suffers from this problem of only providing a set of interventions without an order. Like MINT, C3G considers causal dependencies while producing counterfactuals. However, unlike MINT, C3G relies on Answer Set Programming to generate the counterfactuals.

2.3 Answer Set Programming (ASP)

Answer Set Programming (ASP) is a paradigm for knowledge representation and reasoning [6, 8]. Widely used in automating commonsense reasoning, ASP inherently supports non-monotonic reasoning allowing conclusions to be retracted when new information becomes available. This is helpful in dynamic environments where inter-feature relationships may evolve, allowing ASP to reason effectively in the presence of incomplete or changing knowledge. In ASP, we can model the effect of interventions by defining rules that encode the relationship between variables. ASP can simulate interventions through causal rules. For example, rules in ASP specify that when $P$ is $TRUE$, $Q$ follows, and similarly, when $P$ is $FALSE$, $Q$ is also $FALSE$: $(P\Rightarrow Q)$ $\wedge$ $(\neg P\Rightarrow\neg Q)$. By changing $P$ (representing an intervention), ASP can simulate the effect of this change in $Q$, thereby capturing causal dependencies similar to SCMs. Unlike DAG-based SCMs, ASP rules can natively encode cycles. A recurrent relationship—low_credit_score :- high_debt. and high_debt :- low_credit_score.—captures the mutual reinforcement between credit score and debt that a DAG based SCM would forbid. Conditional dependencies are equally succinct; e.g., loan_approved :- high_income, not low_credit_score. states that high income secures approval only if credit score is not low. This expressiveness allows ASP to model intricate, sometimes cyclic feature interactions encountered in real datasets, complementing SCMs where strict acyclicity is too restrictive.

To execute ASP programs efficiently, s(CASP) [1] is used. It is a goal-directed ASP system that executes answer set programs in a top-down manner without grounding. Its query-driven nature aids in commonsense and counterfactual reasoning, utilizing proof trees for justification. To incorporate negation, s(CASP) adopts program completion as shown [2], turning “if” rules into “if and only if” rules: $(P\Rightarrow Q)$ $\wedge$ $(\neg P\Rightarrow\neg Q)$. Through these mechanisms, ASP in P2C provides a novel framework for generating realistic counterfactual explanations in a step-by-step manner.

2.4 FOLD-SE

A good example of a rule-based machine learning (RBML) algorithm for classification is FOLD-SE [20]. FOLD-SE, being efficient and explainable, generates default rules—a stratified normal logic program—as an explainable model from the given input dataset. Both numerical and categorical features are allowed. The generated rules symbolically represent the machine learning model that will predict a label, given a data record. FOLD-SE can also be used for learning rules capturing causal dependencies among features in a dataset. FOLD-SE maintains scalability and explainability, as it learns a relatively small number of rules and literals regardless of dataset size, while retaining good classification accuracy compared to state-of-the-art machine learning methods.

3 Overview

3.1 The Problem

In high-stakes decision-making systems, individuals (represented as a set of features) often receive undesired negative decisions (e.g., loan denial) from black-box machine learning models. These models lack transparency, making it difficult to understand why a decision was made and what changes are necessary to flip it to a positive outcome. P2C automatically identifies these changes. For example, if John is denied a loan (initial state $i$), P2C models the set of all (positive) scenarios (goal set $G$) where he obtains the loan. Out of these scenarios, John wishes to reach the scenario requiring minimal effort (minimal causally compliant counterfactual $g\in G$). The query goal ‘?- reject_loan(john)’ represents the prediction of the classification model regarding whether John’s loan should be rejected, based on the extracted underlying logic of the model used for loan approval. The (negative) decision in the initial state $i$ should not apply to any scenario in the goal set $G$. The query goal ‘?- reject_loan(john)’ should be True in the initial state $i$ and False for all goals in the goal set $G$. The problem is to find a series of interventions, namely, changes to feature values, that will take John from $i$ to $g\in G$.

3.2 Solution: P2C Approach

P2C finds the path from an initial state $i$ to the minimal causally compliant counterfactual $g\in G$ with each state represented as feature-value pairs (e.g., credit score: 620; debt: [math]). This is done in a three-step process: 1) Black-Box Model Approximation: The black-box model $D$ is approximated using a RBML algorithm (FOLD-SE), generating an explainable surrogate model $H$ that mimics the black-box model’s $D$ decision-making. Optional: In case the causal model $C$ is not provided, it is learned using FOLD-SE. The learned explainable causal model $C$ is then verified by domain experts to check that indeed causality and not correlation is captured. 2) Causal-Aware Counterfactual Search: Using ASP-based reasoning using $C$ and $D$, P2C identifies causally feasible changes that transition the input from $i$ to $G$. Optimized Cost Computation: Unlike prior methods, P2C distinguishes between direct interventions and automatic causal effects, ensuring cost is assigned only to user-initiated changes (direct changes). Using this, P2C computes the minimal causally compliant counterfactual $g\in G$. 3) Planning: Using $D$ and $C$, generate a step-by-step plan of interventions to go from $i$ to $g\in G$.

This generation of a plan is a planning problem. However, unlike the standard planning problem, the interventions that take us from one state to another are not mutually independent: there may exist a causal dependency. P2C ensures that each intervention respects casual dependencies between variables, offering an explanation of how one action leads to the next. The step-wise approach of P2C contrasts with approaches like MINT, which applies all interventions simultaneously. Such simultaneous interventions are not helpful for understanding the dynamic changes in systems with complex causal relationships. The objective is to turn a negative decision (initial state $i$) into a positive one (goal state $g$) through necessary changes to feature values, so that the query goal ‘?- not reject_loan(john)’ will succeed for $g\in G$.

P2C models a path between two scenarios: 1) the negative outcome world (e.g., loan denial, initial state $i$), and 2) the positive outcome world (e.g., loan approval, goal state $g$) achieved through specific interventions. Both states are defined by specific attribute values (e.g., loan approval requires a credit score $\geq$ 620). P2C symbolically computes the necessary interventions to find a path from $i$ to $g$, representing a flipped decision. When the decision query (e.g., ‘?- reject_loan/1’) succeeds (negative outcome), P2C finds the state where this query fails (e.g., ‘?- not reject_loan/1’ succeeds), which constitutes the goal state $g$. In terms of ASP, the task is as follows: given a world where a query succeeds, compute changes to feature values (accounting for causal dependencies) to reach another world where negation of the query will succeed. Each intermediate world traversed must be viable with respect to the rules, i.e., the traversed worlds must be realistic. We use the s(CASP) query-driven predicate ASP system for this purpose.

P2C employs two kinds of actions: 1) Direct Actions: directly changing a feature value, and 2) Causal Actions: changing other features to cause the target feature to change, utilizing the causal dependencies between features. These actions guide the individual from $i$ to $g$ through intermediate states, suggesting realistic and achievable changes. Unlike P2C, the other approaches [19], [10] can output non-viable solutions as they assume feature independence.

Example 1: Using direct actions to reach the counterfactual state Consider a loan application scenario. There are five feature-domain pairs: 1) Age: {1 year,…, 99 years}, 2) Debt: {\1$, …,$$1000000}, 3) Loan Duration: {1\ month,\ ...,\ 60\ months}, 4) Bank Balance: {$0$, …,$$1\ billion} and 5) Credit Score: {300\ points,...,850\ points}. John (31 years, $5000$, 12 months,$$40000$,$599\ points$) applies for a loan. Based on the extracted underlying logic of the classifier for loan rejection, the bank denies his loan (negative outcome) as his *bank balance* is **less than$$60000$**. To get approval (positive outcome), *P2C* recommends: **Initial state**: John (31 years,$$5000$, 12 months,$$40000$,$599\ points$) is denied a loan. **Goal state**: John (31 years,$$5000$, 12 months,$$60000$,$599\ points$) is approved. **Intervention**: Increase the *bank balance* to$$60000$. As shown in Fig. 1, the direct action flips the decision, making John eligible for the loan.

**Example 2: Utility of Causal Actions

**The extracted underlying logic of the classifier for loan rejection produces two rejection rules: 1) individuals with a bank balance of **less than \60000$**, and 2) individuals with a *credit score* below$620$. John (31 years,$$5000$,$12$months,$$40000$,$599\ points$) is denied a loan (negative outcome) but wants approval (positive outcome). Without causal knowledge, the solution would be: **Interventions**: 1) Change the *bank balance* to$$60000$, and 2) the *credit score* to$620\ points$. However, *credit score* cannot be changed directly. To realistically increase the *credit score*, the bank’s guidelines suggest **having no debt**, indicating a causal dependency between *debt* and *credit score*. *P2C* recommends: **Initial state**: John (31 years,$$5000$, 12 months,$$40000$,$599\ points$) is denied a loan. **Goal state**: John (31 years,$$0$, 12 months,$$60000$,$620\ points$) is approved for a loan. **Interventions**: 1) John increases *bank balance* to$$60000$, and 2) *reduces debt* to$0 to increase his credit score. From Figure 1 clearing the debt (direct action) leads to an increase in credit score (causal action), making John eligible for the loan. Intermediate states (e.g., ‘\5000$in *debt*’ and ‘$$0$in *debt*’) represent the path to$g$. We demonstrated how leveraging causal dependencies between features leads to realistic desired outcomes through appropriate interventions.

The challenge now is (i) identifying causal dependencies either by applying common knowledge or through the help of domain experts to the rules learned by using rule-based machine learning algorithms (RBML) (in case the causal model is not provided to us), and (ii) computing the sequence of necessary interventions while avoiding repeating states— a known issue in planning. P2C addresses these by generating the path from $i$ to $g\in G$.

4 Methodology

We next outline the methodology used by P2C to generate paths from the initial state (negative outcome) to the goal state (positive outcome). In Step 1, we utilize the causal and decision rules to obtain a minimal causally compliant counterfactual $g\in G$. For Step 2, unlike traditional planning problems where actions are typically independent, our approach involves interdependent actions governed by causal rules $C$. This ensures that the effect of one action can influence subsequent actions, making interventions realistic and causally consistent. Note that in cases where the causal model is not provided, the P2C framework uses the FOLD-SE RBML algorithm to automatically compute causal dependency rules. These rules have to be either verified by a human, or commonsense knowledge must be used to verify them automatically. This is important, as RBML algorithms can identify a correlation as a causal dependency. P2C uses the former approach. We next define specific terms.

Definition 1 (State Space (S))

$S$ represents all combinations of feature values. For domains $D_{1},...,D_{n}$ of the features $F_{1},...,F_{n}$, $S$ is a set of possible states $s$, where each state is defined as a tuple of feature values $V_{1},...,V_{n}$.

[TABLE]

E.g., an individual John: s = $(31$ years, \5000$,$12$,$$40000$,$599$points$)$, where$s\in S$.

Definition 2 (Causally Consistent State Space ($S_{C}$))

$S_{C}$ is a subset of $S$ where all causal rules are satisfied. $C$ represents a set of causal rules over the features within a state space $S$. Then, $\theta_{C}:P(S)\rightarrow P(S)$ (where $P(S)$ is the power set of S) is a function that defines the subset of a given state sub-space $S^{\prime}\subseteq S$ that satisfy all causal rules in C.

[TABLE]

[TABLE]

E.g., causal rules state that if $debt$ is [math], the credit score should be above 599, then instance $s_{1}$ = (31 years, $0, 12,$40000, 620 points) is causally consistent, and instance $s_{2}$ = (31 years, $0, 12,$40000, 400 points) is causally inconsistent.

In a traditional planning problem, allowed actions in a given state are independent, i.e., the result of one action does not influence another. In P2C, causal actions are interdependent, governed by $C$.

Definition 3 (Decision Consistent State Space ($S_{Q}$))

$S_{Q}$ is a subset of $S_{C}$ where all decision rules are satisfied. $Q$ represents a set of rules that compute some external decision for a given state. $\theta_{Q}:P(S)\rightarrow P(S)$ is a function that defines the subset of the causally consistent state space $S^{\prime}\subseteq S_{C}$ that is also consistent with decision rules in $Q$:

[TABLE]

Given $S_{C}$ and $\theta_{Q}$, we define the decision consistent state space $S_{Q}$ as

[TABLE]

E.g., an individual John whose loan has been rejected: *s = ($31$ years, \0$,$12$,$$40000$,$620$points)*, where$s\in S_{Q}$.

Definition 4 (Initial State ($i$))

$i$ is the starting point with an undesired outcome. Initial state $i$ is an element of the causally consistent state space $S_{C}$

[TABLE]

For example, i=(31\ years,\ \0,\ $40000,\ 620\ points)$

Definition 5 (Actions)

The set of actions $A$ includes all possible interventions (actions) that can transition a state from one to another within the state space. Each action $a\in A$ is defined as a function that maps $s$ to a new state $s^{\prime}$.

[TABLE]

Actions are divided into: 1) Direct Actions: Directly change the value of a single feature of a state $s$, e.g., Increase bank balance from \40000$to$$60000$. 2) Causal Actions: Change the value of a target feature by altering related features, based on causal dependencies. It results in a causally consistent state with respect to C, e.g., reduce debt to increase the credit score.

Definition 6 (Transition Function)

A transition function $\delta:S_{C}\times A\rightarrow S_{C}$ maps a causally consistent state to the set of allowable causally consistent states that can be reached in a single step, and is defined as:

[TABLE]

$\delta$ models a function that repeatedly takes actions until a causally consistent state is reached. In example 1, $\delta$ suggests changing the bank balance from \40000$to$$60000$:$\delta(31\ years,$5000,$40000,599)=$$(31\ years,$5000,$60000,599)$

Definition 7 (Counterfactual Generation (CFG) Problem)

A counterfactual generation (CFG) problem is a 4-tuple $(S_{C},S_{Q},I,\delta)$ where $S_{C}$ is causally consistent state space, $S_{Q}$ is the decision consistent state space, $I\in S_{C}$ is the initial state, and $\delta$ is a transition function.

Definition 8 (Goal Set)

The goal set $G$ is the set of desired outcomes that do not satisfy the decision rules $Q$. For the Counterfactual Generation (CFG) problem $(S_{C},S_{Q},I,\delta)$: $G=\{s\in S_{C}|s\not\in S_{Q}\}$.

$G$ includes all states in $S_{C}$ that do not satisfy $S_{Q}$. For example 1, g = (31 years, $0,$60000, 620 points) $\mid$ g$\in$G.

Definition 9 (Solution Path)

A solution to the problem $(S_{C},S_{Q},I,\delta)$ with goal set $G$ is a path:

[TABLE]

For example 1, individuals with less than \60000$in their account are ineligible for a loan, thus the state of an ineligible individual$s\in S_{Q}$might be$s=(31\ years,$5000,12,$40000,599\ points)$. The goal set has only one goal state$g\in G$given by$g=(31\ years,$5000,12,$60000,599\ points)$. The path from$s$to$gis {*(31 years,5000,12, $40000, 599 points)$\rightarrow DirectAction:\ Increase\ bank\ balance$*$\rightarrow$*(31 years,$5000,12,$60000,599 points)$}$*. Here, the path has only 2 states as only changing the *bank balance* to be$$60000$ is needed to reach the goal state.

Algorithms: We now detail the algorithmic framework of P2C, which produces the minimal causally compliant counterfactual (MCCC) and constructs feasible paths from the original instance $i$ to the MCCC. The workflow comprises three stages: 1) Rule extraction: derive a rule-based approximation $Q$ of the black-box classifier $M$ using a rule-based machine-learning (RBML) algorithm; 2) MCCC Search: Identify the MCCC $s^{*}$ that satisfies the causal model $C$; and 3) Path finding: compute a causally compliant sequence of actions that transforms the initial instance $i$ into $s^{*}$. The remainder of this section presents the top-level procedure, followed by detailed pseudocode for every subroutine.

4.1 Algorithm for P2C:

Algorithm 1 provides the pseudocode for obtaining a feasible path from the original instance $i$ to a minimal causally compliant counterfactual (MCCC) through the following three-step procedure: 1) Extract Logic: Algorithm 2 extracts a rule-based approximation $Q$ of the black-box classifier $M$ using an RBML algorithm $R$. A causal model $C$ is supplied; if absent, we learn a candidate $C$ from the data and have domain experts validate its causal soundness. 2) MCCC search: Given $Q$, $C$, the initial state $i$, feature-change weights $W$, and state-space $S$ (Sec. 4 Def. 1), Algorithm 3 returns the MCCC $s^{*}$. 3) Find Path: Algorithm 4 then computes a feasible path from $i$ to $s^{*}$.

4.2 Algorithm to Extract Decision Rules

The function ‘extract_logic’ extracts the underlying logic of the classification model used for decision-making. Algorithm 2 provides the pseudocode for ‘extract_logic’, which takes the original classification model $M$, input data $H$, and a RBML algorithm $R$ as inputs and returns $Q$, the underlying logic of the classification model. If $M$ is already rule-based, we set $Q=M$. Otherwise, we first label the data $H$ with the model $M$ and set the label to $V\ =\ predict(M(H))$. We then train the RBML algorithm $R$ on $H$ and $V$ to return a surrogate rule set $Q$. This $Q$ captures the decision logic responsible for the undesired outcomes.

4.3 Algorithm to Obtain the Minimal Effort Counterfactual

Algorithm 3 provides the pseudo-code for ‘min_cg’ which returns the MCCC given the initial state $i$, Decision Rules $Q$, Causal Model $C$ and State Space $S$ (Sec. 4 Def. 1). It calls is_counterfactual which is True if the state is a causally consistent counterfactual. For each candidate state, min_cf calls is_counterfactual and sets zero to the weights of features changed automatically by causal dependencies. Hence causally compliant incur zero cost. Finally, compute_weighted_Lp measures the distance from the initial state to each valid counterfactual, taking into account only direct user-initiated changes. The algorithm then returns the counterfactual with the lowest total cost.

4.4 Algorithm to Obtain a path to the Counterfactual

We next describe our algorithm to find the goal states and compute the solution paths, find_path, which makes use of the following functions: (i) not_member: checks if an element is: a) not a member of a list, and b) Given a list of tuples, not a member of any tuple in the list. (ii) drop_inconsistent: given a list of states [$s_{0},...,s_{k}$] and a set of Causal rules $C$, it drops all the inconsistent states resulting in a list of consistent states with respect to $C$. (iii) get_last: returns the last member of a list. (iv) pop: returns the last member of a list. (v) intervene: performs interventions/ makes changes to the current state through a series of actions and returns a list of visited states. The interventions are causally compliant. Further details are available in the supplement.

Function ‘find_path’ implements the Solution Path $P$ of Definition 9. Its purpose is to find a path to the counterfactual state. Algorithm 4 provides the pseudo-code for ‘find_path’, which takes as input an Initial State $i$, a set of Causal Rules $C$, Decision Rules $Q$, and Actions $A$. It returns a path to the counterfactual state/goal state $g\in G$ for the given $i$ as a list ‘visited_states’. Unrealistic states are removed from ‘visited_states’ to obtain a ‘candidate_path’.

Initially, $s=i$. The function checks if the current state $s$ is a counterfactual. If $s$ is already a counterfactual, ‘find_path’ returns a list containing $s$. If not, the algorithm moves from $s=i$ to a new causally consistent state $s^{\prime}$ using the ‘intervene’ function, updating ‘visited_states’ with $s^{\prime}$. It then checks if $s^{\prime}$ = $s^{*}$, i.e., the (MCCC). If True, the algorithm drops all inconsistent states from ‘visited_states’ and returns the ‘candidate_path’ as the path from $i$ to $s^{\prime}$. If not, it updates ‘$current\_state$’ to $s^{\prime}$ and repeats until reaching the minimal causally compliant counterfactual (MCCC) state $s^{*}$. The algorithm ends when the last state in the list ‘visited_states’ is $s^{*}$, i.e. $g\in G$.

4.4.1 Discussion:

(i) Certain features are immutable or restricted: for example, age cannot decrease and credit score cannot be altered directly. To restrict the set of admissible actions without adding new states, we introduce plausibility constraints. These constraints are encoded in the action set in Algorithms 4. (ii) Direct-Path Length (DPL): P2C begins with DPL = 1, searching for counterfactuals achievable via a single direct change, i.e., change through a single direct action; if none exist, it incrementally increases DPL until a solution is found. This guarantees counterfactuals that are minimal and causally consistent. (iii) Since P2C relies heavily on backtracking, we implement it in the goal-directed ASP system s(CASP), which provides built-in backtracking support.

4.5 Soundness

Definition 10 (CFG Implementation)

When Algorithm 4 is executed with the inputs: Initial State $i$ (Definition 4), States Space $S$ (Definition 1), Set of Causal Rules $C$ (Definition 2), Set of Decision Rules $Q$ (Definition 3), and Set of Actions $A$ (Definition 5), a CFG problem $(S_{C},S_{Q},I,\delta)$ (Definition 7) with causally consistent state space $S_{C}$ (Definition 2), Decision consistent state space $S_{Q}$ (Definition 3), Initial State $i$ (Definition 4), the transition function $\delta$ (Definition 6) is constructed.

Definition 11 (Candidate path)

Given the counterfactual $(S_{C},S_{Q},I,\delta)$ constructed from a run of algorithm 4, the return value (candidate path) is the resultant list obtained from removing all elements containing states $s^{\prime}\not\in S_{C}$.

Definition 10 maps the input of Algorithm 4 to a CFG problem (Definition 7). Candidate path maps the result of Algorithm 4 to a possible solution (Definition 9) of the corresponding CGF problem. From Theorem 1 (proof in supplement), the candidate path (Definition 11) is a solution to the corresponding CFG problem implementation (Definition 10).

Theorem 1 Soundness: Given a CFG $\mathbb{X}$=$(S_{C},S_{Q},I,\delta)$, constructed from a run of Algorithm 4 & a corresponding candidate path $P$, $P$ is a solution path for $\mathbb{X}$. Proof is provided in the supplement .

5 Experiments

Our experiments address three questions: 1) How effective is P2C’s refined cost metric; 2) How does P2C scale as the search space increases?; and 3) Do the path-to-counterfactuals produced by P2C outperform those produced by a standard path finder? We evaluate on: Adult [3], Statlog (German Credit) [9], and the Car evaluation [5] datasets. These datasets include demographic and decision labels such as credit risk (‘good’ or ‘bad’), income (‘=<\50k/year$’ or ‘$>$50k/year$’), and used car acceptability. We relabeled the car evaluation dataset -*‘acceptable’* or *‘unacceptable’*- to generate the counterfactuals. For the German dataset, *P2C* identifies paths that convert a ‘*bad*’ credit rating to ‘*good*’ to determine the criteria for a favourable credit risk. Similarly, *P2C* identifies paths for converting the undesired outcomes in the *Adult* and *Car Evaluation* datasets-‘$=<$50k/year$’ and *‘unacceptable’*-to their counterfactuals: ‘$>$50k/year$’ and ‘acceptable’. We use P2C to obtain counterfactual paths. Further details and the implementation are provided in the supplement.

5.1 Comparison of Counterfactual Proximity

To show the effectiveness of P2C’s refined cost metric, we compare it against another ASP based causally compliant counterfactual method: C3G [7]. C3G and P2C use the same Decision and Causal Rules. While C3G is not designed to produce L1 and L2 norms (as it returns counterfactual ranges), we have modified it to obtain each individual counterfactual point and hence obtain L1 and L2 norms. Table 2 demonstrates that for datasets with causal dependencies, P2C consistently produces counterfactuals closer or equal to that of C3G across all metrics—nearest, furthest, and average distances—regardless of norm—L0 or L1 or L2—used. This is inspite of C3G and P2C using the same decision rules $Q$ and the same causal rules $C$. This is because P2C correctly accounts for causal dependencies, treating causally induced changes as cost-free, whereas C3G incorrectly assigns a cost to all feature modifications, including those that occur naturally (causal effect). For both the Adult and German datasets, P2C counterfactuals exhibit lower nearest, furthest, and average distances/cost than C3G. This highlights that P2C identifies more efficient intervention strategies, ensuring that users receive recourse recommendations requiring minimal effort while remaining causally compliant. However for the Cars dataset, since we have not identified any causal dependencies, the performance of P2C is identical to C3G. Overall for causal datasets, the reduced distance across metrics confirms that P2C outperforms C3G in generating counterfactuals with minimum cost.

5.2 Reducing Search Space for Scalability

P2C can be computationally heavy as it explores an expanding search space for counterfactuals. For scalability, we consolidated feature values independent of decision/causal rules into placeholders. For example, the rule: loan_accept:- marital_status(married). with domain: married,unmarried,separated, we replace unmarried, separated with a placeholder (e.g., ph_married), reducing the domain size from 3 to 2. This reduces the search-space (the product of effective domain sizes) without altering the core algorithm. From Table 1, we see that place-holding not only reduces the search-space but also reduces the average time to find a counterfactual.

5.3 P2C: Comparison of the quality of the Path Generated

We evaluate P2C against counterfactual-based approaches: Borderline Counterfactuals [19], DiCE [12], MACE [10], MINT [11] and C3G [7]. Since none of these methods natively support path-finding, we use a standard planner to find a path to the counterfactual state. We aim to show that the path-finding approach of P2C is causally compliant and does not produce any illegal actions (such as directly increasing the credit score) compared to using a standard path-finding algorithm. We use the following metrics: 1) Causal Compliance: $TRUE$/$FALSE$ values indicate whether the method is designed to handle causal dependencies; 2) Causal Consistency: The percentage of the generated counterfactuals that are causally compliant.; 3) Path to counterfactuals: $TRUE$/$FALSE$ values indicate whether the path to the counterfactual contains legal actions, i.e. actions that respect causal dependencies.

As seen in Table 3, P2C produces causally compliant counterfactuals 100% of the time. Unlike a similar causally compliant counterfactual method such as MINT and C3G, it provides a path with only legal actions leading to the counterfactual state. This path is designed to utilize causal dependencies and generate causal actions, something the standard path-finding algorithm cannot do. The only case where the standard path-finder matches the performance of P2C is for the Cars dataset when we do not know the causal dependencies.

6 Conclusion and Future Work

The main contribution of this paper is the P2C framework, which automatically generates paths to a minimal causally compliant counterfactual for any machine learning model—statistical or rule-based. P2C is model agnostic. By incorporating Answer Set Programming (ASP), P2C ensures that the counterfactual generated is causally compliant and delivered through a sequence of actionable interventions, making it more practical for real-world applications compared to current counterfactual methods. While a limitation of P2C lies in it being computationally expensive, a proposed solution involves mapping multiple independent feature values to a single placeholder value to reduce the search space and in turn reduce the complexity. Additionally, P2C is limited to tabular data, future tasks will explore extending P2C to non-tabular data– such as image classification tasks [13].

7 Supplementary Material

Link to the code can be found in the reference [16], i.e.,

https://anonymous.4open.science/r/Logic-DBD7/

8 Algorithms

8.1 Finding the Minimum Counterfactual

We use the Min_cf_algorithm as described to find the k closest points per each cf range returned. To find the k closest points to a point $q$, we just need to search through the list of points returned by the Min_cf_algorithm for each counterfactual range. The proof of correctness of the Min_cf_algorithm is found in Theorem 9.

8.2 Intervene

Function ‘intervene’ implements the transition function $\delta$ from Definition 6. It is called by ‘find_path’. The primary purpose of ‘intervene’ is to transition from the current state to the next state, ensuring actions are not repeated and states are not revisited. In Algorithm 6, we specify the pseudo-code, which takes as arguments an Initial State $I$ that is causally consistent, a set of Causal Rules $C$, and a set of actions $A$. The function intervene acts as a transition function that takes as input a list visited_states containing the current state $s$ as the last element, and returns the new state $s^{\prime}$ by appending $s^{\prime}$ to visited_states. The new state $s^{\prime}$ is what the current state $s$ traverses. Additionally, the function intervene ensures that no states are revisited. In traversing from $s$ to $s^{\prime}$, if there are a series of intermediate states that are not causally consistent, it is also included in visited_states, thereby depicting how to traverse from 1 causally consistent state to another.

8.3 Checking for Counterfactual/Goal State: is_counterfactual

The function is_counterfactual is our algorithmic implementation of checking if a state $s\in G$ from definition 8. In Algorithm 7, we specify the pseudo-code for a function is_counterfactual which takes as arguments a state $s\in S$, a set of causal rules $C$, and a set of Decision rules $Q$. The function checks if a state $s\in S$ is a counterfactual/goal state. By definition is_counterfactual is $TRUE$ for state $s$ that is causally consistent with all $c\in C$ and does not agree with the any decision rules $q\in Q$.

[TABLE]

8.4 Make Consistent

The pseudo-code for ‘make_consistent’ is specified in Algorithm 8. It takes as arguments a current State $s$, a list actions_taken, a list visited_states, a set of Causal Rules $C$ and a set of actions $A$. Called by ‘intervene’, ‘make_consistent’ transitions from the current state to a new, causally consistent state.

8.5 Update

Function ‘update’ tracks the list of actions taken and states visited to avoid repeating actions and revisiting states. In Algorithm 9, we specify the pseudo-code for the update function, that given a state $s$, list actions_taken, list visited_statesand given an action $a$, appends $a$ to actions_taken. It also appends the list actions_taken as well as the new resultant state resulting from the action $a(s)$ to the list visited_states. The list actions_taken is used to track all the actions attempted from the current state to avoid repeating them. The function update is called by both functions intervene and make_consistent.

9 Proofs

Min_Cf_ Theorem

We claim that the Proof of Correctness of the Algorithm 5.

Statement

Let $X_{1},X_{2},\ldots,X_{N}$ be sets of real numbers, and consider the Cartesian product:

[TABLE]

Given a query point $\mathbf{q}=(q_{1},q_{2},\ldots,q_{N})\in\mathbb{R}^{N}$ that is not necessarily in $\mathcal{X}$, and a distance metric $d$ (e.g., $L_{1}$, $L_{2}$, or $L_{0}$), let $S_{k}\subseteq\mathcal{X}$ denote the set of the $k$ points in $\mathcal{X}$ closest to $\mathbf{q}$ under $d$.

Let $X_{i}^{\prime}\subseteq X_{i}$ be the set of $k$ values in $X_{i}$ closest to $q_{i}$, for each $i=1,\ldots,N$. Define:

[TABLE]

Then:

[TABLE]

Proof (for $L_{0}$ , $L_{1}$ and $L_{2}$)

Assume, for the sake of contradiction, that there exists a point $\mathbf{x}=(x_{1},x_{2},\ldots,x_{N})\in S_{k}$ such that $\mathbf{x}\notin\mathcal{X}^{\prime}$. Then, there exists a non-empty index set $J\subseteq\{1,\ldots,N\}$ such that for all $j\in J$, we have $x_{j}\notin X_{j}^{\prime}$.

By definition of $X_{j}^{\prime}$, this means that for each $j\in J$, there exist at least $k$ elements $x_{j}^{(1)},x_{j}^{(2)},\ldots,x_{j}^{(k)}\in X_{j}^{\prime}$ such that:

[TABLE]

For each $j\in J$, choose an index $m_{j}\in\{1,\ldots,k\}$ and define $x_{j}^{(m_{j})}\in X_{j}^{\prime}$ as one of the values strictly closer to $q_{j}$ than $x_{j}$. This gives us a selected replacement value for each coordinate $j\in J$.

We now construct a new point $\mathbf{x}^{\prime}=(x_{1}^{\prime},x_{2}^{\prime},\ldots,x_{N}^{\prime})\in\mathcal{X}$ where:

[TABLE]

Now consider the distance from $\mathbf{x}^{\prime}$ to $\mathbf{q}$.

Case 1: $L_{1}$ distance

[TABLE]

Case 2: $L_{2}$ distance

[TABLE]

[TABLE]

Case 3: $L_{0}$ distance

The $L_{0}$ distance counts the number of coordinates in which two vectors differ:

[TABLE]

Assume, for the sake of contradiction, that there exists a point $\mathbf{x}=(x_{1},\ldots,x_{N})\in S_{k}$ such that $\mathbf{x}\notin\mathcal{X}^{\prime}$. Then there exists a non-empty index set $J\subseteq\{1,\ldots,N\}$ such that for all $j\in J$, we have $x_{j}\notin X_{j}^{\prime}$.

For each $j\in J$, let $x_{j}^{(m_{j})}\in X_{j}^{\prime}$ be one of the values closer to $q_{j}$ than $x_{j}$. Define the point $\mathbf{x}^{\prime}=(x_{1}^{\prime},\ldots,x_{N}^{\prime})\in\mathcal{X}$ as:

[TABLE]

Then, since $x_{i}^{(m_{i})}$ is closer to $q_{i}$ than $x_{i}$, two cases arise:

• •

If $x_{i}^{(m_{i})}=q_{i}$, then the contribution to $d_{0}$ from coordinate $i$ is 0 (improvement).

• •

Now, if $x_{i}^{(m_{i})}\neq q_{i}$, then the contribution to $d_{0}$ from coordinate $i$ remains 1. (Note: Since $x_{i}$ is further away from $q_{i}$ than $x_{i}^{(m_{i})}$, its original contribution to $d_{0}$ was already 1 since $x_{i}\neq q_{i}$.)

Thus, the overall L0 distance does not increase.

[TABLE]

This contradicts the assumption that $\mathbf{x}\in S_{k}$, so we conclude:

[TABLE]

$\blacksquare$

Theorem 9.1

*Soundness Theorem

Given a CFG $\mathbb{X}=(S_{C},S_{Q},I,\delta)$, constructed from a run of algorithm 4 and a corresponding candidate path $P$, $P$ is a solution path for $\mathbb{X}$.*

Proof

Let $G$ be a goal set for $\mathbb{X}$. By definition 11 $P=s_{0},...,s_{m}$, where $m\geq 0$. By definition 9 we must show $P$ has the following properties.

1) $s_{0}=I$

2) $s_{m}\in G$

3) $s_{j}\in S_{C}\ for\ all\ j\ \in\{0,...,m\}$

4) $s_{0},...,s_{m-1}\not\in G$

*5) *$s_{i+1}\in\delta(s_{i})\ for\ i\ \in\{0,...,m-1\}$

1) By definition 4, $I$ is causally consistent and cannot be removed from the candidate path. Hence I must be in the candidate path and is the first state as per line 2 in algorithm 4. Therefore $s_{0}$ must be $I$.

2) The while loop in algorithm 5 ends if and only if $is\_counterfactual(s,C,Q)$ is True. From theorem 1 $is\_counterfactual(s,C,Q)$ is True only for the goal state. Hence $s_{m}\in G$.

3) By definition11 of the candidate path, all states $s_{j}\in S_{C}\ for\ all\ j\ \in\{0,...,m\}$.

4) By theorem 9.4, we have proved the claim $s_{0},...,s_{m-1}\not\in G$.

5) By theorem 9.3, we have proved the claim $s_{i+1}\in\delta(s_{i})\ for\ i\ \in\{0,...,m-1\}$.

Hence we proved the candidate path $P$ (definition 11) is a solution path (definition 9).

Theorem 9.2

Given a CFG $\mathbb{X}=(S_{C},S_{Q},I,\delta)$, constructed from a run of algorithm 4, with goal set $G$, and $s\in S_{C}$; $is\_counterfactual(s,C,Q)$ will be $TRUE$ if and only if $s\in G$.

Proof

By the definition of the goal set $G$ we have

[TABLE]

For $is\_counterfactual$ which takes as input the state $s$, the set of causal rules $C$ and the set of decision rules $Q$ (Algorithm 7), we see that by from line 1 in algorithm 7, it returns TRUE if it satisfied all rules in $C$ and no rules in $Q$.

By the definition 3, $s\in S_{Q}$ if and only if it satisfies a rule in $Q$. Therefore, $is\_counterfactual(s,C,Q)$ is $TRUE$ if and only if $s\not\in S_{Q}$ and since $s\in S_{C}$ and $s\not\in S_{Q}$ then $s\in G$.

Theorem 9.3

Given a CFG $\mathbb{X}=(S_{C},S_{Q},I,\delta)$, constructed from a run of algorithm 4 and a corresponding candidate path $P=s_{0},...,s_{m}$; $s_{i+1}\in\delta(s_{i})\ for\ i\ \in\{0,...,m-1\}$

Proof

This property can be proven by induction on the length of the list visited_lists obtained from Algorithm 5,4,3.

Base Case*: The list visited_lists from algorithm 4 has length of 1, i.e., [$s_{0}$]. The property $s_{i+1}\in\delta(s_{i})\ for\ i\ \in\{0,...,m-1\}$ is trivially true as there is no $s_{-1}$.*

Inductive Hypotheses*: We have a list [$s_{0},...,s_{n-1}$] of length $n$ generated from [math] or more iteration of running the function intervene (algorithm 6), and it satisfies the claim *$s_{i+1}\in\delta(s_{i})\ for\ i\ \in\{0,...,n-1\}$

Inductive Step*: If we have a list [$s_{0},...,s_{n-1}$] of length n and we wish to get element $s_{n}$ obtained through running another iteration of function intervene (algorithm 6). Since [$s_{0},...,s_{n-1}$] is of length n by the inductive hypothesis, it satisfies the property, and it is sufficient to show $s_{n}\in\delta(s_{n-1})$ where $s_{i+1}\in\delta(s_{i})\ for\ i\ \in\{0,...,n-1\}$.*

The list visited_lists from algorithm 4 has length of $n$. Going from $s_{n-1}$ to $s_{n}$ involves calling the function intervene (algorithm 6) which in turn calls the function make_consistent (algorithm 8).

Function make_consistent (algorithm 8) takes as input the state $s$, the list of actions taken actions_taken, the list of visited states visited_states, the set of causal rules $C$ and the set of possible actions $A$. It returns visited_states with the new causally consistent states as the last element. From line 1, if we pass as input a causally consistent state, then function make_consistent does nothing. On the other hand, if we pass a causally inconsistent state, it takes actions to reach a new state. Upon checking if the action taken results in a new state that is causally consistent from the while loop in line 1, it returns the new state. Hence, we have shown that the moment a causally consistent state is encountered in function make_consistent, it does not add any new state.

Function intervene (algorithm 6) takes as input the list of visited states visited_states which contains the current state as the last element, the set of causal rules $C$ and the set of possible actions $A$. It returns visited_states with the new causally consistent states as the last element. It calls the function make_consistent. For the function intervene, in line 1 it obtains the current state (in this case $s_{n-1}$) from the list visited_states. It is seen in line 2 that an action $a$ is taken:

1) Case 1: If a causal action is taken, then upon entering the the function make_consistent (algorithm 8), it will not do anything as causal actions by definition result in causally consistent states.

2) Case 2: If a direct action is taken, then the new state that may or may not be causally consistent is appended to visited_states. The call to the function make_consistent will append one or more states with only the final state appended being causally consistent.

Hence we have shown that the moment a causally consistent state is appended in function intervene, it does not add any new state. This causally consistent state is $s_{n}$. In both cases $s_{n}=\sigma(s_{n-1})$ as defined in definition 10 and this $s_{n}\in\delta(s_{n-1})$.

Theorem 9.4

Given a CFG $\mathbb{X}=(S_{C},S_{Q},I,\delta)$, constructed from a run of algorithm 4, with goal set $G$ and a corresponding candidate path $P=s_{0},...,s_{m}$ with $m\geq 0$, $s_{0},...,s_{m-1}\not\in G$.

Proof

This property can be proven by induction on the length of the list visited_lists obtained from Algorithm 5,4,3.

Base Case*: visited_lists has length of 1. Therefore the property $P=s_{0},...,s_{m}$ with $m\geq 0$, $s_{0},...,s_{m-1}\not\in G$ is trivially true as state $s_{j}$ for $j<0$ does not exist.*

Inductive Hypotheses*: We have a list [$s_{0},...,s_{n-1}$] of length $n$ generated from [math] or more iteration of running the function intervene (algorithm 6), and it satisfies the claim $s_{0},...,s_{n-2}\not\in G$.*

Inductive Step*: Suppose we have a list [$s_{0},...,s_{n-1}$] of length n and we wish to append the n+1 th element (state $s_{n}$) by calling the function intervene, and we wish to show that that the resultant list satisfies the claim $s_{0},...,s_{n-1}\not\in G$. The first n-1 elements ($s_{0},...,s_{n-2}$) are not in $G$ as per the inductive hypothesis.*

From line 3 in the function get_path (algorithm 4), we see that to call the function intervene another time, the current state (in this case $s_{n-1})$ cannot be a counterfactual, by theorem 9.2. Hence $s_{n-1}\not\in G$

Therefore by induction the claim $s_{0},...,s_{n-1}\not\in G$ holds.

10 Experiments

10.1 Tables from Experiments

11 Experimental Setup

11.0.1 Dataset: Adult

We run the FOLD-SE algorithm to produce the following decision making rules:

label(X,’<=50K’) :- not marital_status(X,’Married-civ-spouse’)

, capital_gain(X,N1), N1=<6849.0.

label(X,’<=50K’) :- marital_status(X,’Married-civ-spouse’)

, capital_gain(X,N1), N1=<5013.0, education_num(X,N2), N2=<12.0.

Accuracy: 84.5% 2. 2.

Precision: 86.5% 3. 3.

Recall: 94.6%

2. FOLD-SE gives Causal rules for the ‘marital_status’ feature having value ‘never_married’:

marital_status(X,’Never-married’) :- not relationship(X,’Husband’),

not relationship(X,’Wife’), age(X,N1), N1=<29.0.

Accuracy: 86.4% 2. 2.

Precision: 89.2% 3. 3.

Recall: 76.4%

3. FOLD-SE gives Causal rules for the ‘marital_status’ feature having value ‘Married-civ-spouse’:

marital_status(X,’Married-civ-spouse’) :- relationship(X,’Husband’).

marital_status(X,’Married-civ-spouse’) :- relationship(X,’Wife’).

Accuracy: 99.1% 2. 2.

Precision: 99.9% 3. 3.

Recall: 98.2%

4. For values of the feature ‘marital_status’ that are not ‘Married-civ-spouse’ or ‘never_married’ which we shall call ‘neither’, a user defined rule is used

marital_status(X,neither) :- not relationship(X,’Husband’)

, not relationship(X,’Wife’).

5. FOLD-SE gives Causal rules for the ‘relationship’ feature having value ‘husband’:

relationship(X,’Husband’) :- not sex(X,’Male’), age(X,N1), not(N1=<27.0).

Accuracy: 82.3% 2. 2.

Precision: 71.3% 3. 3.

Recall: 93.2%

5. For the ‘relationship’ feature value of ‘wife’, a user defined rule is used

relationship(X,’Wife’) :- sex(X,’Female’).

6)Features Used in Generating the counterfactual path:

• •

Feature: marital_status

• •

Feature: relationship

• •

Feature: sex

• •

capital_gain

• •

education_num

• •

age

11.0.2 Dataset: German

We run the FOLD-SE algorithm to produce the following decision making rules:

label(X,’good’) :- checking_account_status(X,’no_checking_account’)

label(X,’good’) :- not checking_account_status(X,’no_checking_account’) , not credit_history(X,’all_dues_atbank_cleared’) , duration_months(X,N1), N1=<21.0, credit_amount(X,N2) , not(N2=<428.0), not ab1(X,’True’).

ab1(X,’True’) :- property(X,’car or other’)

, credit_amount(X,N2), N2=<1345.0.

Accuracy: 77% 2. 2.

Precision: 83% 3. 3.

Recall: 84.2%

2. FOLD-SE gives Causal rules for the ‘present_employment_since’ feature having value ‘employed’ where employed is the placeholder for all feature values that are not equal to the feature value ‘unemployed’:

present_employment_since(X,’employed’) :-

not job(X,’unemployed/unskilled-non_resident’).

Accuracy: 95% 2. 2.

Precision: 96.4% 3. 3.

Recall: 98.4%

3. For values of the feature ‘present_employment_since’ that are ‘unemployed’, a user defined rule is used

present_employment_since(X,’unemployed’) :-

job(X,’unemployed/unskilled-non_resident’).

6)Features Used in Generating the counterfactual path:

• •

checking_account_status

• •

credit_history

• •

property

• •

duration_months

• •

credit_amount

• •

present_employment_since

• •

job

11.0.3 Dataset: Cars

We run the FOLD-SE algorithm to produce the following rules:

label(X,’negative’) :- persons(X,’2’).

label(X,’negative’) :- safety(X,’low’).

label(X,’negative’) :- buying(X,’vhigh’), maint(X,’vhigh’).

label(X,’negative’) :- not buying(X,’low’), not buying(X,’med’), maint(X,’vhigh’).

label(X,’negative’) :- buying(X,’vhigh’), maint(X,’high’).

The rules described above indicate if the purchase of a car was rejected .

Accuracy: 93.9% 2. 2.

Precision: 100% 3. 3.

Recall: 91.3%

2. Features and Feature Values used:

• •

Feature: persons

• •

Feature: safety

• •

Feature: buying

• •

Feature: maint