SlowGuess/NeurIPS_2023_OCR huggingface dataset:
Corollary 3.4. Problems 1 and 2 are NP-complete under Assumption 2.1.
It is noteworthy that the size of the problem depends on the number of vertices of  $\mathcal{G}$ , i.e.,  $|V^{\mathcal{G}}|$ , and the number of edges of  $\mathcal{G}$  with finite weight, i.e.,  $|E^{\mathcal{G}}| = |E_d^{\mathcal{G}}| + |E_b^{\mathcal{G}}|$ . Since the ID algorithm (function ID of [26]) runs in time  $\mathcal{O}(|V^{\mathcal{G}}|^2)$ , the brute-force algorithm that tests the identifiability of  $Q[Y]$  in every edge-induced subgraph of  $\mathcal{G}$  and chooses the one with the minimum weight of deleted edges runs in time  $\mathcal{O}(2^{|E^{\mathcal{G}}|}|V^{\mathcal{G}}|^2)$ . In the next Section, we present various algorithmic approaches for solving or approximating the solutions to these problems.
4 Algorithmic approaches
We first present a recursive approach for solving the edge ID problem in Section 4.1, described in Algorithm 1. Since the problem itself is NP-complete, Algorithm 1 runs in exponential time in the worst case. In Section 4.2, we present heuristic approximations of the edge ID problem, which runs in cubic time in the worst case. These heuristics can also be used as a pre-process to reduce the runtime of Alg. 1 by providing an upper bound that can be fed into Alg. 1 to prune the search space. Finally, in Section 4.3, we present a reduction of edge ID to yet another NP-complete problem, namely minimum-cost intervention problem [2], which allows us to use the algorithms designed for that problem to solve edge ID. Our simulations in Section 5 evaluate these approaches against each other.
4.1 Recursive exact algorithm
This approach is described in Algorithm 1. The inputs to the algorithm are an ADMG  $\mathcal{G}$  along with edge weights  $W_{\mathcal{G}}$ , a set of vertices  $Y$  corresponding to the causal query  $Q[Y]$ , an upper bound  $\omega^{ub}$  on the aggregate weight (cost) of the optimal solution, and a threshold  $\omega^{th}$ , an upper bound on the acceptable cost of a solution. The closer  $\omega^{ub}$  is to the optimal cost, the quicker Algorithm 1 will find the solution. If no upper bound is known, the algorithm can be initiated with  $\omega^{ub} = \infty$ . However, we shall discuss a few approaches to find a good upper bound  $\omega^{ub}$  in the following Section. Note that when  $\omega^{th} = 0$ , Algorithm 1 will output the optimal solution. Otherwise, as soon as a feasible solution with weight less than  $\omega^{th}$  is found, the algorithm terminates (line 13).
The algorithm begins with calling subroutine  $\mathbf{M}\mathbf{H}$  in line 2, which constructs the maximal hedge for  $Q[Y]$ , denoted by  $\mathcal{H}$ . We discuss this subroutine in detail in Appendix B. Throughout the rest of the algorithm, we only consider the edges in  $\mathcal{H}$ , as the other edges do not alter the identifiability. If there is no hedge formed for  $Q[Y]$ , i.e.,  $\mathcal{H} = \mathcal{G}[Y]$ , there is no need to remove any edges from  $\mathcal{G}$  and the effect is already identified. Otherwise, we remove the edge with the lowest weight  $(e)$  from  $\mathcal{H}$  and recursively call the algorithm to find the solution after removing the edge  $e$ , unless the weight of  $e$  is already higher than the upper bound  $\omega^{ub}$ , which means no feasible solutions exist for the provided upper bound. Whenever a feasible solution is found, the upper bound  $\omega^{ub}$  is updated to the lowest weight among all the solutions weights discovered so far. This, in turn, helps the algorithm prune the exponential search space during the next iterations to reduce the runtime. As soon as a solution with a weight less than the acceptable threshold, i.e.,  $\omega^{th}$ , is found, the algorithm returns the solution. Otherwise,  $w_{e}$  is updated to infinity so that it never gets removed (line 14). This is due to the fact that we have already explored all the solutions involving  $e$ .
Algorithm 1 Recursive Algorithm for edge ID.
1: function EDGEID  $(\mathcal{G},Y,W_{\mathcal{G}},\omega^{ub},\omega^{th})$   
2:  $\mathcal{H}\gets \mathbf{MH}(\mathcal{G},Y)$   
3: if  $\mathcal{H} = \mathcal{G}[Y]$  then return (True,  $\emptyset$ )  
4:  $ID,E_{min}\gets False,\emptyset$   
5: while True do  
6:  $e\gets$  The edge of  $\mathcal{H}$  with minimum weight  
7: if  $w_{e} = \infty$  or  $w_{e} > \omega^{ub}$  then return  $(ID,E_{min})$   
8:  $(id,E)\gets \mathbf{EDGEID}(\mathcal{H}\backslash e,Y,W_{\mathcal{G}}\backslash \{w_e\},\omega^{ub} - w_e,\omega^{th} - w_e)$   
9: if  $id = True$  then  
10:  $\omega_{E}\gets w_{e} + \sum_{e_{j}\in E}w_{e_{j}}$   
11:  $ID\gets True,\quad \omega^{ub}\gets \omega_{E}$   
12:  $E_{min}\gets E\cup \{e\}$   
13: if  $\omega^{ub}\leq \omega^{th}$  then return  $(ID,E_{min})$   
14: Update  $w_{e}\gets \infty$  in  $W_{\mathcal{G}}$
4.2 Heuristic algorithms
In this section, we present two heuristic algorithms for approximating the solution to the edge ID problem. These algorithms can also be used to efficiently find the upper bound  $\omega^{ub}$ , which could be fed as an input to Algorithm 1.
Algorithm 2 Heuristic algorithm for edge ID.
1: function HEID(G,Y,WG)  
2:  $\mathcal{G}^{\prime}\gets \mathbf{MH}(\mathcal{G},Y)$   
3:  $Z\gets \{z\in V^{\mathcal{G}^{\prime}}|\exists y\in Y:\{z,y\} \in E_{b}^{\mathcal{G}^{\prime}}\} \setminus Y,$   
4:  $\mathcal{H}\gets$  induced subgraph of  $\mathcal{G}^{\prime}$  on its directed edges.  
5:  $W_{\mathcal{H}}\gets \{w_e\in W_{\mathcal{G}}|e\in \mathcal{H}\}$ ,  $V^{\mathcal{H}}\gets V^{\mathcal{H}}\cup \{y^{*},z^{*}\}$   
6: for  $z\in Z$  do  $E^{\mathcal{H}}\gets E^{\mathcal{H}}\cup (z^{*},z)$ ,  $W_{\mathcal{H}}\gets W_{\mathcal{H}}\cup \{w_{(z^{*},z)} = \sum_{y}w_{\{z,y\}}\}$   
7: for  $y\in Y$  do  $E^{\mathcal{H}}\gets E^{\mathcal{H}}\cup (y,y^{*})$ ,  $W_{\mathcal{H}}\gets W_{\mathcal{H}}\cup \{w_{(y,y^{*})} = \infty \}$   
8:  $E\gets \text{MinCut}(\mathcal{H},W_{\mathcal{H}},z^{*},y^{*})$   
9: return  $(E,\sum_{e\in E}w_e)$
Let  $Z = \{z \in V^{\mathcal{G}} \mid \exists y \in Y : \{z, y\} \in E_b^{\mathcal{G}}\} \setminus Y$  denote the set of vertices that have at least one common bidirected edge with a vertex in  $Y$ . Any hedge formed for  $Q[Y]$  contains at least one vertex of  $Z$ . As a result, to eliminate all the hedges formed for  $Q[Y]$ , it suffices to ensure that none of the vertices in  $Z$  appear in such a hedge. To this end, for any  $z \in Z$ , it suffices to either remove all the bidirected edges between  $z$  and  $Y$  or eliminate all the directed paths from  $z$  to  $Y$ . The problem of eliminating all directed paths from  $Z$  to  $Y$  can be cast as a minimum cut problem between  $Z$  and  $Y$  in the edge-induced subgraph of  $\mathcal{G}$  over its directed edges. To add the possibility of removing the bidirected edges between  $Z$  and  $Y$ , we add an auxiliary vertex  $z^*$  to the graph and draw a directed edge from  $z^*$  to every  $z \in Z$  with weight  $w = \sum_{y \in Y} w_{\{z, y\}}$ , i.e., the sum of the weights of all bidirected edges between  $z$  and  $Y$ . Note that  $z$  can have bidirected edges to multiple vertices in  $Y$ . We then solve the minimum cut problem for  $z^*$  and  $Y$ . If an edge between  $z^*$  and  $z \in Z$  is included in the solution to this minimum cut problem, it is mapped to remove all the bidirected edges between  $z$  and  $Y$  in the main problem. Note that we can run the algorithm on the maximal hedge formed for  $Q[Y]$  in  $\mathcal{G}$  rather than  $\mathcal{G}$  itself. This heuristic is presented as Algorithm 2.
An analogous approach which goes through solving an undirected minimum cut on the edge-induced subgraph of  $\mathcal{G}$  over its bidirected edges is presented in Algorithm 4 in Appendix D. As mentioned earlier, these algorithms can be used either as standalone algorithms to approximate the solution to the edge ID problem, or as a pre-processing step to find an upper bound  $\omega^{ub}$  for Algorithm 1.
Complexity and performance. The aforementioned heuristic algorithms can be broken down into two primary components: constructing an instance of the minimum-cut problem, and solving the latter. Both algorithms follow similar steps for constructing the minimum-cut problem. For reference,
(a) ADMG  $\mathcal{G},Y = \{y_1,y_2\}$
(b) ADMG  $\mathcal{H}$ $Y^{mcip} = \{y_1,y_2,y_2^{12}\}$
Figure 3: Reduction from edge ID to MCIP.
Alg. 2 starts with identifying the maximal hedge formed for  $Q[Y]$ , which is cubic-time in the worst case [2], followed by forming a directed graph  $\mathcal{H}$  over the vertices of the maximal hedge. Forming this graph, which inherits its vertices and directed edges from  $\mathcal{G}$ , is linear in time. Lastly, there exist several minimum-cut-maximum-flow algorithms that exhibit cubic-time performance. Therefore, our heuristic algorithms have a cubic runtime in the worst case. On the other hand, given the hardness result we provided in the previous section, and in light of the fact that there is a polynomial-time reduction from the minimum hitting set problem to MCIP [3], the edge ID problem is NP-hard to approximate within a factor better than logarithmic [11]. Since our heuristic algorithms run in polynomial time, they are expected to be suboptimal by at least a logarithmic factor in the worst case. However, as we shall see in our simulations, both algorithms achieve near-optimal results on random graphs.
4.3 Alternative approach: reduction to MCIP
As an alternative approach to the algorithms discussed so far, we present a reduction of the edge ID problem to another NP-complete problem, i.e., the minimum-cost intervention problem (MCIP) introduced in [2]. This reduction allows us to exploit algorithms designed for MCIP to solve our problems. The formal definition of MCIP is as follows.
Definition 4.1 (MCIP). Suppose  $\mathcal{G} = (V^{\mathcal{G}},E_d^{\mathcal{G}},E_b^{\mathcal{G}})$  is an ADMG,  $C:V^{\mathcal{G}}\to \mathbb{R}^{\geq 0}$  is a cost function mapping each vertex of  $\mathcal{G}$  to a non-negative cost, and  $Y\subseteq V^{\mathcal{G}}$ . The objective of the minimum-cost intervention problem for identifying the causal effect  $Q[Y]$  is to find the subset  $A\subseteq V^{\mathcal{G}}$  with the minimum aggregate cost such that  $Q[Y]$  is identifiable after intervening on the set  $A$ .
The reduction from edge ID to MCIP is based on a transformation from ADMG  $\mathcal{G}$  to another ADMG  $\mathcal{H}$ , where each edge in  $\mathcal{G}$  is represented by a vertex in  $\mathcal{H}$ . This transformation is based on the causal query  $Q[Y]$ , and it maps the identifiability of  $Q[Y]$  in  $\mathcal{G}$  to the identifiability of  $Q[Y^{mcip}]$  in  $\mathcal{H}$ , where  $Y^{mcip}$  is a set of vertices in  $\mathcal{H}$ . This transformation satisfies the following property; removing a set of edges  $E^*$  in  $\mathcal{G}$  makes  $Q[Y]$  identifiable if and only if intervening on the corresponding vertices of  $E^*$  in  $\mathcal{H}$  makes  $Q[Y^{mcip}]$  identifiable. More precisely, after this transformation, solving the edge ID problem for  $Q[Y]$  in  $\mathcal{G}$  is equivalent to solving MCIP for  $Q[Y^{mcip}]$  in  $\mathcal{H}$ . The complete details of this transformation can be found in Appendix A.2. An example of this reduction is shown in Figure 3, where  $Q[\{y_1, y_2\}]$  in  $\mathcal{G}$  (Figure 3a) is mapped to  $Q[\{y_1, y_2, y_2^{12}\}]$  in  $\mathcal{H}$  (Figure 3b), where  $\{y_1, y_2, y_2^{12}\}$  is a district, and the set of all vertices of  $\mathcal{H}$  forms a hedge for it. The vertices of  $\mathcal{H}$  corresponding to each edge in  $\mathcal{G}$  are indicated with the same color and have the same weight (cost). We assign infinity cost to them to avoid intervening on the remaining vertices in  $\mathcal{H}$ . It is straightforward to see that the solution to the edge ID problem in  $\mathcal{G}$  with the query  $Q[Y = \{y_1, y_2\}]$  would be to remove the edge with the lowest weight. This is because after removing any edge in  $\mathcal{G}$ , no hedge remains for  $Q[Y]$ . Similarly, in  $\mathcal{H}$ , the solution to MCIP with the query  $Q[Y^{mcip} = \{y_1, y_2, y_2^{12}\}]$  is to intervene on the vertex with the lowest cost among  $Z = \{z_{11}^d, x_{21}^d, x_{12}^b, y_{12}^b, z_{22}^b\}$ . This is because after intervening on any vertex in  $Z$ , no hedge remains for  $Q[Y^{mcip}]$ . The following result establishes the link between the edge ID problem in  $\mathcal{G}$  and MCIP in  $\mathcal{H}$ .
(a) Runtimes.
(b) Solution costs.
Figure 4: Experimental results for runtime, solution costs, fraction of graphs for which no solution was found, and fraction of graphs for which runtime limit of 3 minutes was exceeded. Error bars for runtime and cost graphs indicate 5th and 95th percentiles. Best viewed in color.
(c) Fraction runtime exceeded  $3\mathrm{min}$
Proposition 4.2. There exists a polynomial-time reduction from edge ID to MCIP and vice versa.
In particular, the time complexity of the transformation from edge ID to MCIP scales linearly in size of  $\mathcal{G}$ , and is cubic in  $|Y|$ . More precisely, the time complexity is  $\mathcal{O}(|V^{\mathcal{G}}| + |E_d^{\mathcal{G}}| + |E_b^{\mathcal{G}}| + |Y|^3)$ . For further details, refer to the construction in Appendix A.2.
We evaluate the proposed heuristic algorithms 2 (HEID-1) and 4 (HEID-2), as well as the exact algorithm 1 (EDGEID), where the upper-bound  $\omega^{ub}$  for EDGEID is set to be the minimum cost found by HEID-1 or -2. Furthermore, given the reduction of the edge ID problem to the MCIP problem described in Section 4.3, we also evaluate the two approximation and one exact algorithms from [2] (MCIP-H1, MCIP-H2, and MCIP-exact, respectively). Experimental results are provided for Problem 1, and analogous results for Problem 2 are provided in Appendix E.3. All experiments were carried out on an Intel i9-9900K CPU running at  $3.6\mathrm{GHz}^4$ .
Simulations: The algorithms are evaluated for graphs with between 5 and 250 vertices. For a given number of vertices, we uniformly sample 50 ADMG structures from a library of graphs which are non-isomorphic to each other. Edges for each of these 100 graphs are sampled with probability of  $\log (n) / n$ , where  $n$  is the number of (observable) vertices, to impose sparsity (thus pragmatically reducing the search space). For each graph, we sample directed and bidirected edge probabilities  $p_e$  uniformly between 0.51 and  $1.0^5$ . The problem is then converted into edge ID according to Lemma 3.2. The vertices in the graphs are topologically sorted and the outcome  $Y$  is selected to be the last vertex in the topological ordering. We then check whether a solution exists in principle by removing all finite cost edges and checking for identifiability. If not, a new graph is sampled to avoid evaluating the algorithms on graphs with no solution. For each of these 50 probabilistic ADMGs, we run the algorithms and record the resulting runtime and the associated cost of the solution. If the runtime exceeds 3 minutes, we abort and log that the algorithm has failed to find a solution.
Results are presented in Figure 4. Runtimes and costs are shown for the subset of graphs for which all algorithms found a solution (to facilitate comparison). Runtimes for each algorithm are shown in Fig. 4a, where it can be seen that our proposed HEID-1 and HEID-2 heuristic algorithms have negligible runtime, followed by the MCIP variants. Interestingly, the exact algorithm EDGEID outperformed the MCIP algorithms on larger graphs, for which the transformation time from the edge ID problem to the MCIP increases with the size of the graph. In contrast, EDGEID had large runtime variance which depended heavily on the specifics of the graph under evaluation, particularly for graphs with fewer vertices. The costs for each graph are shown in Fig. 4b, and here we see, as expected, the lowest cost is achieved by the two exact algorithms, EDGEID and MCIP-exact, followed closely by the heuristic algorithms. Figure 4c shows the fraction of evaluations for which the runtime exceeded 3 minutes (applicable to the exact algorithms). In general, and owing to the sparsity
To replicate our findings, our Python implementations are accessible via https://github.com/SinaAkbarii/Causal-Effect-Identification-in-Uncertain-Causal-Networks and https://github.com/matthewvowels1/NeurIPS_testbed ADMGs.
Note that we do not consider edge probabilities less than 0.5 as from Lemma 3.2, such edges would be mapped to edges with 0 weight in the equivalent edge ID problem, which can always be removed at the beginning.
Table 1: Time (seconds), cost, and ratio  $P(\hat{\mathcal{G}}^{*}) / P(\mathcal{G})$  for seven algorithms over four real-world datasets. A dash - indicates the maximum runtime (500 seconds) exceeded.
Algorithm	Psych	Barley	Alarm	Water
Time	Cost	Ratio	Time	Cost	Ratio	Time	Cost	Ratio	Time	Cost	Ratio
HEID-1	0.0019	2.648	0.07	0.0026	0.081	0.92	0.0004	0.0	1.0	0.0019	1.02	0.36
HEID-2	0.0019	1.806	0.16	0.0026	0.081	0.92	0.0003	0.0	1.0	0.0017	0.42	0.66
MCIP-H1	0.0136	2.648	0.07	0.0140	0.081	0.92	0.0027	0.0	1.0	0.0124	1.02	0.36
MCIP-H2	0.0133	1.806	0.16	0.0131	0.081	0.92	0.0029	0.0	1.0	0.0113	0.42	0.66
MCIP-exact	-	-	-	0.0099	0.081	0.92	0.0028	0.0	1.0	0.0221	0.42	0.66
EDGEID	-	-	-	-	-	-	0.0005	0.0	1.0	-	-	-
penalty in our graph generation mechanism, the cost of identified solutions falls with the number of vertices. However, among the exact algorithms, EDGEID, exceeds the 3-minute runtime more often than the MCIP-Exact, regardless of the number of vertices and despite the fact that EDGEID is quicker at finding a solution when it does so. Overall, HEID-1 was the most consistent in finding a solution, having a short runtime, and achieving a close to optimal cost.
Real-world graphs: We also apply the algorithms to four real-world datasets. The first 'Psych' (22 nodes & 70 directed edges) concerns the putative structure from a causal discovery algorithm Structural Agnostic Model [18] using data collected as part of the Health and Relationships Project [32]. The other three 'Barley' (48 nodes & 84 directed edges), 'Water' (32 nodes & 66 directed edges), and 'Alarm' (37 nodes & 46 directed edges) come from the bnlearn python package [28]. For all four graphs, and as with the simulations described above, we introduce bidirected edges with a sparsity constraint of  $\log(n)/n$ , and simulate expert domain knowledge by randomly assigning directed and bidirected edge probabilities between 0.51 and 1. The outcome  $Y$  is selected to be the last vertex in the topological ordering. For these results, we provide the runtime (limited to 500 seconds) and cost, as well as the ratio of graph plausibility before and after selecting a subgraph in which the effect is identifiable  $P(\hat{\mathcal{G}^*})/P(\mathcal{G})$ . This ratio is 1.0 if the effect is identifiable in the original graph and decreases according to the plausibility of an identified subgraph.
Results are shown in Table 1. In cases where MCIP-exact and/or EDGEID did not exceed the runtime limit, it can be seen that HEID-2 and MCIP-H2 achieved equivalent to optimal cost and ratio. Runtimes for MCIP variants exceeded the HEID variants owing to the required transformation. EDGEID timed out on all but the Alarm structure, whereas MCIP-exact only timed out on the Psych structure, indicating that the MCIP-exact is more consistent (this also corroborates Figure 4c).
6 Concluding remarks
Researchers in causal inference are often faced with graphs for which the effect of interest is not identifiable. It is common to identify a target effect by assuming ignorability. A less drastic and more reasonable approach would be to relax this assumption by identifying the most plausible subgraph, given uncertainty about the structure as we suggested in this work. We presented a number of algorithms for finding the most probable/plausible probabilistic ADMG in which the target causal effect is identifiable. We provided an analysis of the complexity of the problem, and an experimental comparison of runtimes, solution costs, and failure rates. We noted that our heuristic algorithms, Alg. 2 and Alg. 4 performed remarkably well across all metrics. In terms of limitations, we made the assumption that the edges in  $\mathcal{G}$  are mutually independent (Assumption 2.1). Future work should explore the case where this assumption does not hold. In this work, we studied the problem of point identification of the target effect. We envision that a similar methodology can be applied to partial identification. Finally, it is worth noting that the external validity of the derived subgraph (i.e., whether or not the subgraph is correctly specified with respect to the corresponding real-world process) is not guaranteed. As such, practitioners using such approaches are encouraged to do so with caution, particularly for research involving human participants.
This research was in part supported by the Swiss National Science Foundation under NCCR Automation, grant agreement 51NF40_180545 and Swiss SNF project 200021_204355 /1.
[20] Yaroslav Kivva, Ehsan Mokhtarian, Jalal Etesami, and Negar Kiyavash. Revisiting the general identifiability problem. In Uncertainty in Artificial Intelligence, pages 1022-1030. PMLR, 2022.
[21] Sanghack Lee, Juan D Correa, and Elias Bareinboim. General identifiability with arbitrary surrogate experiments. In Uncertainty in artificial intelligence, pages 389-398. PMLR, 2020.
[22] Dimitris Margaritis and Sebastian Thrun. Bayesian network induction via local neighborhoods. Advances in neural information processing systems, 12, 1999.
[23] Judea Pearl. Aspects of graphical models conncted with causality. Proceedings of the 49th Session of the International Statistical Institute, pages 399-401, 1993.
[24] Judea Pearl. Causality. Cambridge University Press, Cambridge, 2009.
[25] Rajen D. Shah and Jonas Peters. The hardness of conditional independence testing and the generalised covariance measure. The Annals of Statistics, 48(3), 2020.
[26] Ilya Shpitser and Judea Pearl. Identification of joint interventional distributions in recursive semi-Markovian causal models. In Proceedings of the National Conference on Artificial Intelligence, volume 21, page 1219. Menlo Park, CA; Cambridge, MA; London; AAAI Press; MIT Press; 1999, 2006.
[27] Peter Spirtes, Clark N. Glymour, and D. Scheines, Richard and Heckerman. Causation, prediction, and search. MIT press, 2000.
[28] Erdogan Taskesen. bnlearn - Library for Bayesian network learning and inference. Python Library, 2020.
[29] Jin Tian and Judea Pearl. A general identification condition for causal effects. AAAI, 2002.
[30] Jin Tian and Judea Pearl. On the testable implications of causal models with hidden variables. In Proceedings of the Eighteenth conference on Uncertainty in artificial intelligence, pages 519-527, 2002.
[31] Santtu Tikka, Antti Hyttinen, and Juha Karvanen. Identifying causal effects via context-specific independence relations. Advances in neural information processing systems, 32, 2019.
[32] Debra Umberson. Health and relationships project. Inter-university consortium for political and social research, 2014-2015.
[33] Mark J. van der Laan and Sherri Rose. Targeted Learning - Causal Inference for Observational and Experimental Data. Springer International, New York, 2011.
The appendices are organized as follows. Formal proofs of the results stated in the main text are presented in Section A. In Section B, we describe the algorithm to recover the maximal hedge formed for a certain query (Def. 2.5), which is used as a subroutine of Algorithm 1. A generalization of Assumption 2.1 is discussed in Section C. Section D provides further details of the heuristic algorithms discussed in the main text. Further evaluations and experimental conditions for our proposed algorithms are presented in Section E.
Table 2: Table of notations
Symbol	Description
VG	Vertices of G
EBG	The set of bidirected edges of G
EDd	The set of directed edges of G
AncG(X)	Ancestors of X in G
M(G)	The set of the all compatible models with G
pe	Probability of edge e
we	Weight of edge e
PX(Y)	Causal effect of X on Y
A Formal proofs