Original: On the Complexity of Counterfactual Reasoning
Revised: On the Complexity of Counterfactual Reasoning

Original: Abstract
Revised: Abstract

Original: A common form of counterfactual reasoning is based on the notion of twin network which is a causal graph that represents two worlds, one real and another imaginary.
Revised: A common form of counterfactual reasoning is based on the notion of twin network which is a causal graph that represents two worlds, one real and another imaginary.

Original: Information about the real world is used to update the joint distribution over the network’s causal mechanisms which is then used for hypothetical reasoning in the imaginary world.
Revised: Information about the real world is used to update the joint distribution over the network’s causal mechanisms which is then used for hypothetical reasoning in the imaginary world.

Original: This is in contrast to associational and interventional reasoning which involve a causal graph over a single world that we shall call a base network.
Revised: This is in contrast to associational and interventional reasoning which involve a causal graph over a single world that we shall call a base network.

Original: We study the complexity of counterfactual reasoning in twin networks in relation to the complexity of associational and interventional reasoning in base networks.
Revised: We study the complexity of counterfactual reasoning in twin networks in relation to the complexity of associational and interventional reasoning in base networks.

Original: We show that counterfactual reasoning is no harder than associational/interventional reasoning in the context of two computational frameworks.
Revised: We show that counterfactual reasoning is no harder than associational/interventional reasoning in the context of two computational frameworks.

Original: One of these is based on the notion of treewidth and includes the classical variable elimination and jointree algorithms.
Revised: One of these is based on the notion of treewidth and includes the classical variable elimination and jointree algorithms.

Original: The second, more recent framework is based on the notion of causal treewidth which is directed towards causal graphs used in counterfactual reasoning (e.g., structural causal models).
Revised: The second, more recent framework is based on the notion of causal treewidth which is directed towards causal graphs used in counterfactual reasoning (e.g., structural causal models).

Original: More specifically, we show that the (causal) treewidth of a twin network is at most twice the (causal) treewidth of its base network plus one.
Revised: More specifically, we show that the (causal) treewidth of a twin network is at most twice the (causal) treewidth of its base network plus one.

Original: This means that if associational/interventional reasoning is tractable in this context, then counterfactual reasoning is also tractable.
Revised: This means that if associational/interventional reasoning is tractable in this context, then counterfactual reasoning is also tractable.

Original: We further extend our results to a form of counterfactual reasoning that is more general than what is commonly discussed in the literature.
Revised: We further extend our results to a form of counterfactual reasoning that is more general than what is commonly discussed in the literature.

Original: We finally present empirical results that measure the gap between the complexities of counterfactual reasoning and associational/interventional reasoning on random structural causal models.
Revised: We finally present empirical results that measure the gap between the complexities of counterfactual reasoning and associational/interventional reasoning on random structural causal models.

Original:  Introduction
Revised:  Introduction

Original: A theory of causality has emerged over the last few decades based on two parallel hierarchies, an information hierarchy and a reasoning hierarchy, often called the causal hierarchy [33].
Revised: A theory of causality has emerged over the last few decades based on two parallel hierarchies, an information hierarchy and a reasoning hierarchy, often called the causal hierarchy [33].

Original: On the reasoning side, this theory has crystalized three levels of reasoning with increased sophistication and proximity to human reasoning: associational, interventional and counterfactual, which are exemplified by the following canonical probabilities.
Revised: On the reasoning side, this theory has crystalized three levels of reasoning with increased sophistication and proximity to human reasoning: associational, interventional and counterfactual, which are exemplified by the following canonical probabilities.

Original: Associational Pr ( y | x ) : probability of y given that x was observed.
Revised: Associational Pr ( y | x ) : probability of y given that x was observed.

Original: Example: probability that a patient has a flu given they have a fever.
Revised: Example: probability that a patient has a flu given they have a fever.

Original: Interventional Pr ( y x ) : probability of y given that x was established by an intervention.
Revised: Interventional Pr ( y x ) : probability of y given that x was established by an intervention.

Original: This is different from Pr ( y | x ) .
Revised: This is different from Pr ( y | x ) .

Original: Example: seeing the barometer fall tells us about the weather but moving the barometer needle won’t bring rain.
Revised: Example: seeing the barometer fall tells us about the weather but moving the barometer needle won’t bring rain.

Original: Counterfactual Pr ( y x | ¯ y, ¯ x ) : probability of y if we were to establish x by an intervention given that neither x nor y are true.
Revised: Counterfactual Pr ( y x | ¯ y, ¯ x ) : probability of y if we were to establish x by an intervention given that neither x nor y are true.

Original: Example: probability that a patient who did not take a vaccine and died would have recovered had they been vaccinated.
Revised: Example: probability that a patient who did not take a vaccine and died would have recovered had they been vaccinated.

Original: On the information side, these forms of reasoning were shown to require different levels of knowledge, encoded as (1) associational models, (2) causal models and (3) functional (mechanistic) models, respectively, with each class of models containing more information than the preceding one.
Revised: On the information side, these forms of reasoning were shown to require different levels of knowledge, encoded as (1) associational models, (2) causal models and (3) functional (mechanistic) models, respectively, with each class of models containing more information than the preceding one.

Original: In the framework of probabilistic graphical models [24], this information is encoded by (1) Bayesian networks [9, 29], (2) causal Bayesian networks [32, 34, 40], and (3) functional Bayesian networks [4, 32].
Revised: In the framework of probabilistic graphical models [24], this information is encoded by (1) Bayesian networks [9, 29], (2) causal Bayesian networks [32, 34, 40], and (3) functional Bayesian networks [4, 32].

Original: Counterfactual reasoning has received much interest as it inspires both introspection and contemplating scenarios that have not been seen before, and is therefore viewed by many as a hallmark of human intelligence.
Revised: Counterfactual reasoning has received much interest as it inspires both introspection and contemplating scenarios that have not been seen before, and is therefore viewed by many as a hallmark of human intelligence.

Original: Figure 1 depicts a functional Bayesian network, also known as a structural causal model (SCM) [18, 19], which can be used to answer counterfactual queries.
Revised: Figure 1 depicts a functional Bayesian network, also known as a structural causal model (SCM) [18, 19], which can be used to answer counterfactual queries.

Original: Variables without causes are called exogenous or root and variables with causes are called endogenous or internal.
Revised: Variables without causes are called exogenous or root and variables with causes are called endogenous or internal.

Original: The only uncertainty in SCMs concerns the states of exogenous variables and this uncertainty is quantified using distributions over these variables.
Revised: The only uncertainty in SCMs concerns the states of exogenous variables and this uncertainty is quantified using distributions over these variables.

Original: Endogenous variables are assumed to be functional: they are functionally determined by their causes where the functional relationships, also known as causal mechanisms, are specified by structural equations.
Revised: Endogenous variables are assumed to be functional: they are functionally determined by their causes where the functional relationships, also known as causal mechanisms, are specified by structural equations.

Original: 1 These equations and the distributions over exogenous variables define the parameters of the causal graph, leading to a fully specified SCM which can be used to evaluate associational, interventional and counterfactual queries.
Revised: 1 These equations and the distributions over exogenous variables define the parameters of the causal graph, leading to a fully specified SCM which can be used to evaluate associational, interventional and counterfactual queries.

Original: For example, the SCM in
Revised: For example, the SCM in

Original: Figure 1 has enough information to evaluate the counterfactual query Pr ( y x
Revised: Figure 1 has enough information to evaluate the counterfactual query Pr ( y x

Original: | ¯ x, ¯ y ) : the probability that a patient who did not take the treatment and died would have been alive had they been given the treatment.
Revised: | ¯ x, ¯ y ) : the probability that a patient who did not take the treatment and died would have been alive had they been given the treatment.

Original: A causal Bayesian network contains less information than a functional one (SCM) as it does not require endogenous variables to be functional, but it is sufficient to compute associational and interventional probabilities.
Revised: A causal Bayesian network contains less information than a functional one (SCM) as it does not require endogenous variables to be functional, but it is sufficient to compute associational and interventional probabilities.

Original: A Bayesian network contains even less information as it does not require network edges to have a causal interpretation, only that the conditional independences encoded by the network are correct, so it can only compute associational probabilities.
Revised: A Bayesian network contains even less information as it does not require network edges to have a causal interpretation, only that the conditional independences encoded by the network are correct, so it can only compute associational probabilities.

Original: All three forms of reasoning (and models) involve a directed acyclic graph (DAG) which we call the base network.
Revised: All three forms of reasoning (and models) involve a directed acyclic graph (DAG) which we call the base network.

Original: The time complexity of associational and interventional reasoning can be bounded by n · exp( w ) where n is the number of network nodes and w is its treewidth (a graph-theoretic measure of connectivity).
Revised: The time complexity of associational and interventional reasoning can be bounded by n · exp( w ) where n is the number of network nodes and w is its treewidth (a graph-theoretic measure of connectivity).

Original: Counterfactual reasoning with two worlds is based on a twin network, obtained by duplicating internal nodes in the base network; see right of Figure 1.
Revised: Counterfactual reasoning with two worlds is based on a twin network, obtained by duplicating internal nodes in the base network; see right of Figure 1.

Original: To compute the counterfactual query Pr ( y x | ¯ y, ¯ x ) , one asserts ¯ y, ¯ x as an observation on one side of the twin network (real world) and computes the interventional query Pr ( y x ) on the other side of the network (imaginary world).
Revised: To compute the counterfactual query Pr ( y x | ¯ y, ¯ x ) , one asserts ¯ y, ¯ x as an observation on one side of the twin network (real world) and computes the interventional query Pr ( y x ) on the other side of the network (imaginary world).

Original: One can also bound the time complexity of reasoning by n t · exp( w t ) where n t is the number of nodes in the twin network and w t is its treewidth.
Revised: One can also bound the time complexity of reasoning by n t · exp( w t ) where n t is the number of nodes in the twin network and w t is its treewidth.

Original: A recent result provides a similar but much tighter bound using the notion of causal treewidth [6, 11], which is no greater than treewidth but applies only when certain nodes in the base network are functional — in SCMs every internal node is functional.
Revised: A recent result provides a similar but much tighter bound using the notion of causal treewidth [6, 11], which is no greater than treewidth but applies only when certain nodes in the base network are functional — in SCMs every internal node is functional.

Original: One would expect the more sophisticated counterfactual reasoning with twin networks to be more expensive than associational/interventional reasoning with base networks since the former networks are larger and have more complex topologies.
Revised: One would expect the more sophisticated counterfactual reasoning with twin networks to be more expensive than associational/interventional reasoning with base networks since the former networks are larger and have more complex topologies.

Original: But the question is: How much more expensive?
Revised: But the question is: How much more expensive?

Original: For example, can associational/interventional reasoning be tractable on a base network when counterfactual reasoning is intractable on its twin network?
Revised: For example, can associational/interventional reasoning be tractable on a base network when counterfactual reasoning is intractable on its twin network?

Original: We address this question in the context of reasoning algorithms whose complexity is exponential only in the (causal) treewidth, such as the jointree algorithm [26], the variable elimination algorithm [48, 15] and circuit-based algorithms [8, 12].
Revised: We address this question in the context of reasoning algorithms whose complexity is exponential only in the (causal) treewidth, such as the jointree algorithm [26], the variable elimination algorithm [48, 15] and circuit-based algorithms [8, 12].

Original: In particular, we show in Sections 3 & 4 that the (causal) treewidth of a twin network is at most twice the (causal) treewidth of its base network plus one.
Revised: In particular, we show in Sections 3 & 4 that the (causal) treewidth of a twin network is at most twice the (causal) treewidth of its base network plus one.

Original: Hence, the complexity of counterfactual reasoning is
Revised: Hence, the complexity of counterfactual reasoning is

Original: [Figure]
Revised: [Figure]

Original: no more than quadratic in the complexity of associational and interventional reasoning so the former must be bounded if the latter is bounded.
Revised: no more than quadratic in the complexity of associational and interventional reasoning so the former must be bounded if the latter is bounded.

Original: We extend our results in Section 5 to counterfactual reasoning that requires contemplating more than two worlds, therefore demanding networks that are more complex than twin networks.
Revised: We extend our results in Section 5 to counterfactual reasoning that requires contemplating more than two worlds, therefore demanding networks that are more complex than twin networks.

Original: Our results apply directly to counterfactual reasoning on fully specified
Revised: Our results apply directly to counterfactual reasoning on fully specified

Original: SCMs but we also discuss in Section 6 how they can sometimes be applied to counterfactual reasoning using data and a partially specified SCM.
Revised: SCMs but we also discuss in Section 6 how they can sometimes be applied to counterfactual reasoning using data and a partially specified SCM.

Original: We finally present empirical results in Section 7 which reveal that, on average, the complexity gap between counterfactual and associational/interventional reasoning on fully specified SCMs can be smaller than what our worst-case bounds may suggest.
Revised: We finally present empirical results in Section 7 which reveal that, on average, the complexity gap between counterfactual and associational/interventional reasoning on fully specified SCMs can be smaller than what our worst-case bounds may suggest.

Original:  Technical Preliminaries
Revised:  Technical Preliminaries

Original: We next review the notions of treewidth [35] and causal treewidth [6, 11, 10] which we use to characterize the computational complexity of counterfactual reasoning on fully specified SCMs.
Revised: We next review the notions of treewidth [35] and causal treewidth [6, 11, 10] which we use to characterize the computational complexity of counterfactual reasoning on fully specified SCMs.

Original: We also review the notions of elimination orders, jointrees and thinned jointrees which are the basis for defining (causal) treewidth and act as data structures that characterize the computational complexity of various reasoning algorithms.
Revised: We also review the notions of elimination orders, jointrees and thinned jointrees which are the basis for defining (causal) treewidth and act as data structures that characterize the computational complexity of various reasoning algorithms.

Original: We use these notions extensively when stating and proving our results (proofs of all results are in the Appendix).
Revised: We use these notions extensively when stating and proving our results (proofs of all results are in the Appendix).

Original: We denote variables by uppercase letters (e.g. X ) and their values by lowercase letters (e.g. x ).
Revised: We denote variables by uppercase letters (e.g. X ) and their values by lowercase letters (e.g. x ).

Original: A set of variables is denoted by a bold uppercase letter (e.g. X ) and its instantiations by a bold lowercase letter (e.g. x ).
Revised: A set of variables is denoted by a bold uppercase letter (e.g. X ) and its instantiations by a bold lowercase letter (e.g. x ).

Original: 2.1 Elimination Orders
Revised: 2.1 Elimination Orders

Original: These are total orders of the network variables which drive, and characterize the complexity of, the classical variable elimination algorithm when computing associational, interventional and counterfactual queries.
Revised: These are total orders of the network variables which drive, and characterize the complexity of, the classical variable elimination algorithm when computing associational, interventional and counterfactual queries.

Original: Consider a DAG G where every node represents a variable.
Revised: Consider a DAG G where every node represents a variable.

Original: An elimination order π for
Revised: An elimination order π for

Original: G is a total ordering of the variables in G , where π ( i ) is the i th variable in the order, starting from i = 1 .
Revised: G is a total ordering of the variables in G , where π ( i ) is the i th variable in the order, starting from i = 1 .

Original: An elimination order defines an elimination process on the moral graph of DAG G which is used to define the treewidth of G .
Revised: An elimination order defines an elimination process on the moral graph of DAG G which is used to define the treewidth of G .

Original: The moral graph G m is obtained from G by adding an undirected edge between every pair of common parents and then removing directions from all directed edges.
Revised: The moral graph G m is obtained from G by adding an undirected edge between every pair of common parents and then removing directions from all directed edges.

Original: When we eliminate variable π ( i ) from G , we connect every pair of neighbors of π ( i ) in G m and remove π ( i ) from G m .
Revised: When we eliminate variable π ( i ) from G , we connect every pair of neighbors of π ( i ) in G m and remove π ( i ) from G m .

Original: This elimination process induces a cluster sequence C 1 , C 2 , . .
Revised: This elimination process induces a cluster sequence C 1 , C 2 , . .

Original: C n , where
Revised: C n , where

Original: C i is π ( i ) and its neighbors in G m just before eliminating π ( i ) .
Revised: C i is π ( i ) and its neighbors in G m just before eliminating π ( i ) .

Original: The width of an elimination order is the size of its largest induced cluster minus 1 .
Revised: The width of an elimination order is the size of its largest induced cluster minus 1 .

Original: The treewidth for DAG G is the minimum width of any elimination order for G .
Revised: The treewidth for DAG G is the minimum width of any elimination order for G .

Original: The variable elimination algorithm computes queries in O ( n · exp( w )) time where n is the number of nodes in the (base or twin) network and w is the width of a corresponding elimination order.
Revised: The variable elimination algorithm computes queries in O ( n · exp( w )) time where n is the number of nodes in the (base or twin) network and w is the width of a corresponding elimination order.

Original: Elimination orders are usually constructed using heuristics that aim to minimize their width.
Revised: Elimination orders are usually constructed using heuristics that aim to minimize their width.

Original: We use the popular minfill heuristic [22] in our experiments while noting that more effective heuristics may exist as shown in [23, 25].
Revised: We use the popular minfill heuristic [22] in our experiments while noting that more effective heuristics may exist as shown in [23, 25].

Original: 2.2 Jointrees
Revised: 2.2 Jointrees

Original: These are data structures that drive, and characterize the complexity of, the classical jointree algorithm; see Figure 2b.
Revised: These are data structures that drive, and characterize the complexity of, the classical jointree algorithm; see Figure 2b.

Original: Let the family of variable X in DAG G be the set f X containing X and its parents in G .
Revised: Let the family of variable X in DAG G be the set f X containing X and its parents in G .

Original: A jointree for DAG G is a pair ⟨T , H⟩ where T is a tree and H is a function that maps each family f of G into nodes H ( f ) in T called the hosts of family f .
Revised: A jointree for DAG G is a pair ⟨T , H⟩ where T is a tree and H is a function that maps each family f of G into nodes H ( f ) in T called the hosts of family f .

Original: The requirements are: only nodes with a single neighbor (called leaves ) can be hosts; each leaf node hosts exactly one family; and each family must be hosted by at least one node.
Revised: The requirements are: only nodes with a single neighbor (called leaves ) can be hosts; each leaf node hosts exactly one family; and each family must be hosted by at least one node.

Original: This induces a cluster C i for each jointree node i and a separator S ij for each jointree edge ( i, j ) which are defined as follows.
Revised: This induces a cluster C i for each jointree node i and a separator S ij for each jointree edge ( i, j ) which are defined as follows.

Original: Separator S ij is the set of variables hosted at both sides of edge ( i, j ) .
Revised: Separator S ij is the set of variables hosted at both sides of edge ( i, j ) .

Original: If jointree node i is a leaf then
Revised: If jointree node i is a leaf then

Original: cluster C
Revised: cluster C

Original: i is the family hosted by i ; otherwise, C i is the union of separators adjacent to node i .
Revised: i is the family hosted by i ; otherwise, C i is the union of separators adjacent to node i .

Original: The width of a jointree is the size of its largest cluster minus 1 .
Revised: The width of a jointree is the size of its largest cluster minus 1 .

Original: The minimum width attained by any jointree for
Revised: The minimum width attained by any jointree for

Original: G corresponds to the treewidth of G .
Revised: G corresponds to the treewidth of G .

Original: The jointree algorithm computes queries in O ( n · exp( w )) time where n is the number of nodes and w is the width of a corresponding jointree.
Revised: The jointree algorithm computes queries in O ( n · exp( w )) time where n is the number of nodes and w is the width of a corresponding jointree.

Original: Jointrees are usually constructed from elimination orders, and there are polytime, width-preserving transformations between elimination orders and jointrees; see [9, Ch 9] for details.
Revised: Jointrees are usually constructed from elimination orders, and there are polytime, width-preserving transformations between elimination orders and jointrees; see [9, Ch 9] for details.

Original: 2.3 Thinned Jointree
Revised: 2.3 Thinned Jointree

Original: To thin a jointree is to remove some variables from its separators (and hence clusters, which are defined in terms of separators); see Figure 2c.
Revised: To thin a jointree is to remove some variables from its separators (and hence clusters, which are defined in terms of separators); see Figure 2c.

Original: Thinning reduces the jointree width, sometimes quite significantly, leading to exponential savings in reasoning time.
Revised: Thinning reduces the jointree width, sometimes quite significantly, leading to exponential savings in reasoning time.

Original: Thinning is possible only when some variables in the network are functional, even without knowing the specific functional relationships (i.e., structural equations).
Revised: Thinning is possible only when some variables in the network are functional, even without knowing the specific functional relationships (i.e., structural equations).

Original: The causal treewidth is the minimum width for any thinned jointree.
Revised: The causal treewidth is the minimum width for any thinned jointree.

Original: Causal treewidth is no greater than treewidth and the former can be bounded when the latter is not.
Revised: Causal treewidth is no greater than treewidth and the former can be bounded when the latter is not.

Original: While this notion can be applied broadly as in [10], it is particularly relevant to counterfactual reasoning since every internal node in an SCM is functional so the causal treewidth for these models can be significantly smaller than their treewidth.
Revised: While this notion can be applied broadly as in [10], it is particularly relevant to counterfactual reasoning since every internal node in an SCM is functional so the causal treewidth for these models can be significantly smaller than their treewidth.

Original: There are alternate definitions of thinned jointrees.
Revised: There are alternate definitions of thinned jointrees.

Original: The next definition is based on thinning rules [6].
Revised: The next definition is based on thinning rules [6].

Original: A thinning rule removes a variable from a separator under certain conditions.
Revised: A thinning rule removes a variable from a separator under certain conditions.

Original: There are two thinning rules which apply only to functional variables.
Revised: There are two thinning rules which apply only to functional variables.

Original: The first rule removes variable X from a separator S ij if edge ( i, j ) is on the path between two leaf nodes that host the family of X and every separator on that path contains X .
Revised: The first rule removes variable X from a separator S ij if edge ( i, j ) is on the path between two leaf nodes that host the family of X and every separator on that path contains X .

Original: The second rule removes variable X from a separator S ij if no other separator
Revised: The second rule removes variable X from a separator S ij if no other separator

Original: S ik contains X , or no other separator S kj contains X .
Revised: S ik contains X , or no other separator S kj contains X .

Original: A thinned jointree is obtained by applying these rules to exhaustion.
Revised: A thinned jointree is obtained by applying these rules to exhaustion.

Original: Figure 2 depicts an optimal, classical jointree and a thinned jointree for the same DAG (the latter has smaller width).
Revised: Figure 2 depicts an optimal, classical jointree and a thinned jointree for the same DAG (the latter has smaller width).

Original: The effectiveness of thinning rules depends on the number of jointree nodes that host a family f , |H
Revised: The effectiveness of thinning rules depends on the number of jointree nodes that host a family f , |H

Original: ( f ) | , and the location of these nodes in the jointree.
Revised: ( f ) | , and the location of these nodes in the jointree.

Original: One can enable more thinnings by increasing the number of jointree nodes that host each family f .
Revised: One can enable more thinnings by increasing the number of jointree nodes that host each family f .

Original: This process is called replication where |H ( f ) | is called the number of replicas for family f .
Revised: This process is called replication where |H ( f ) | is called the number of replicas for family f .

Original: Replication comes at the expense of increasing the number of jointree nodes so the definition of causal treewidth limits this growth by requiring the jointree size to be a polynomial in the number of nodes in the underlying DAG; see [6] for details.
Revised: Replication comes at the expense of increasing the number of jointree nodes so the definition of causal treewidth limits this growth by requiring the jointree size to be a polynomial in the number of nodes in the underlying DAG; see [6] for details.

Original:  The Treewidth of Twin Networks
Revised:  The Treewidth of Twin Networks

Original: Consider Figure 3a which depicts a 2-bit half adder.
Revised: Consider Figure 3a which depicts a 2-bit half adder.

Original: Suppose the binary inputs A and B are randomly sampled from some distribution and the gates may not be functioning properly.
Revised: Suppose the binary inputs A and B are randomly sampled from some distribution and the gates may not be functioning properly.

Original: This circuit can be modeled using the network in Figure 3b.
Revised: This circuit can be modeled using the network in Figure 3b.

Original: Variables A, B, S, C represent the inputs and outputs of the circuit; X, Y represent the health of the XOR gate and the AND gate; and U represents an unknown external random sampler that decides the state of inputs A and B .
Revised: Variables A, B, S, C represent the inputs and outputs of the circuit; X, Y represent the health of the XOR gate and the AND gate; and U represents an unknown external random sampler that decides the state of inputs A and B .

Original: Suppose that currently to be a host of any number of families.
Revised: Suppose that currently to be a host of any number of families.

Original: Our definition facilitates the upcoming treatment and does not preclude optimal jointrees.
Revised: Our definition facilitates the upcoming treatment and does not preclude optimal jointrees.

Original: Thinning rules will not trigger if families are not replicated ( |H ( f ) | = 1 for all f ).
Revised: Thinning rules will not trigger if families are not replicated ( |H ( f ) | = 1 for all f ).

Original: Replication usually increases the width of a jointree from w to w r with the goal of having thinning rules reduce width w r to width w t < w ≤ w r .
Revised: Replication usually increases the width of a jointree from w to w r with the goal of having thinning rules reduce width w r to width w t < w ≤ w r .

Original: The replication strategy may sometimes not be effective on certain networks, leading to w < w t ≤ w r .
Revised: The replication strategy may sometimes not be effective on certain networks, leading to w < w t ≤ w r .

Original: See [6, 10] for some replication strategies.
Revised: See [6, 10] for some replication strategies.

Original: We later use the one in [6] which exhibits this behavior on some networks.
Revised: We later use the one in [6] which exhibits this behavior on some networks.

Original: [Figure]
Revised: [Figure]

Original: U X
Revised: U X

Original: Y
Revised: Y

Original: A
Revised: A

Original: B
Revised: B

Original: S
Revised: S

Original: C
Revised: C

Original: [Figure]
Revised: [Figure]

Original: U X
Revised: U X

Original: Y
Revised: Y

Original: A
Revised: A

Original: B
Revised: B

Original: S
Revised: S

Original: C
Revised: C

Original: [ A ] [ B ] [ S ] [ C ] (c) twin network
Revised: [ A ] [ B ] [ S ] [ C ] (c) twin network

Original: U X
Revised: U X

Original: Y
Revised: Y

Original: A
Revised: A

Original: B
Revised: B

Original: S
Revised: S

Original: C
Revised: C

Original: [ A ] [ B ] [ S ] [ C ] (
Revised: [ A ] [ B ] [ S ] [ C ] (

Original: [Figure]
Revised: [Figure]

Original: mutilated
Revised: mutilated

Original: [Figure]
Revised: [Figure]

Original: input A is high, input B is low, yet both outputs C and S are low which is an abnormal circuit behavior.
Revised: input A is high, input B is low, yet both outputs C and S are low which is an abnormal circuit behavior.

Original: We wish to know whether the half adder would still behave correctly when we turn both inputs A and B on.
Revised: We wish to know whether the half adder would still behave correctly when we turn both inputs A and B on.

Original: This question can be formulated using the following counterfactual query:
Revised: This question can be formulated using the following counterfactual query:

Original: Pr (( c, ¯ s ) a,b | a, ¯ b, ¯ c, ¯ s ) .
Revised: Pr (( c, ¯ s ) a,b | a, ¯ b, ¯ c, ¯ s ) .

Original: This query can be answered using a twin network as shown in Figure 3c, where each non-root variable V has a duplicate [ V ] .
Revised: This query can be answered using a twin network as shown in Figure 3c, where each non-root variable V has a duplicate [ V ] .

Original: The current evidence a, ¯ b, ¯ c, ¯ s is asserted on the variables
Revised: The current evidence a, ¯ b, ¯ c, ¯ s is asserted on the variables

Original: A, B, C, S representing the real world and the interventional query Pr (( c, ¯ s ) a,b ) is computed on the duplicate variables [ A ] , [ B ] , [ C ] , [ S ] representing the imaginary world.
Revised: A, B, C, S representing the real world and the interventional query Pr (( c, ¯ s ) a,b ) is computed on the duplicate variables [ A ] , [ B ] , [ C ] , [ S ] representing the imaginary world.

Original: This is done by removing the edges incoming into the intervened upon variables [ A ] , [ B ] , asserting evidence [ a ] , [ b ] and finally computing the probability of [ c ] , [¯ s ] as shown in Figure 3d; see [32] for an elaborate discussion of these steps.
Revised: This is done by removing the edges incoming into the intervened upon variables [ A ] , [ B ] , asserting evidence [ a ] , [ b ] and finally computing the probability of [ c ] , [¯ s ] as shown in Figure 3d; see [32] for an elaborate discussion of these steps.

Original: This basically illustrates how a counterfactual query can be computed using algorithms for associational queries, like variable elimination, but on a mutilated twin network instead of the base network.
Revised: This basically illustrates how a counterfactual query can be computed using algorithms for associational queries, like variable elimination, but on a mutilated twin network instead of the base network.

Original: We next show that the treewidth of a twin network is at most twice the treewidth of its base network plus one, which allows us to relate the complexities of assocational, interventional and counterfactual reasoning on fully specified SCMs.
Revised: We next show that the treewidth of a twin network is at most twice the treewidth of its base network plus one, which allows us to relate the complexities of assocational, interventional and counterfactual reasoning on fully specified SCMs.

Original: First is the definition of twin networks as proposed by [3].
Revised: First is the definition of twin networks as proposed by [3].

Original: Definition 1.
Revised: Definition 1.

Original: Given a base network G , its twin network G t is constructed as follows.
Revised: Given a base network G , its twin network G t is constructed as follows.

Original: For each internal variable X in G , add a new variable labeled [ X ] .
Revised: For each internal variable X in G , add a new variable labeled [ X ] .

Original: For each parent P of X , if P is an internal variable, make [ P ] a parent of [ X ] ; otherwise, make P a parent of [ X ] .
Revised: For each parent P of X , if P is an internal variable, make [ P ] a parent of [ X ] ; otherwise, make P a parent of [ X ] .

Original: We will call X a base variable and [ X ] a duplicate variable.
Revised: We will call X a base variable and [ X ] a duplicate variable.

Original: For convenience, we use [ U ] =
Revised: For convenience, we use [ U ] =

Original: U when U is root.
Revised: U when U is root.

Original: For variables X , we use [ X ] to denote { [ X ] | X ∈
Revised: For variables X , we use [ X ] to denote { [ X ] | X ∈

Original: X } .
Revised: X } .

Original: Figure 3c depicts the twin network for the base network in Figure 3b.
Revised: Figure 3c depicts the twin network for the base network in Figure 3b.

Original: 3.1 Twin elimination orders
Revised: 3.1 Twin elimination orders

Original: Our result on the treewidth of twin networks is based on converting every elimination order for the base network into an elimination order for its twin network while providing a guarantee on the width of the latter in terms of the width of the former.
Revised: Our result on the treewidth of twin networks is based on converting every elimination order for the base network into an elimination order for its twin network while providing a guarantee on the width of the latter in terms of the width of the former.

Original: We provide a similar result for jointrees that we use when discussing the causal treewidth of twin networks.
Revised: We provide a similar result for jointrees that we use when discussing the causal treewidth of twin networks.

Original: Definition 2.
Revised: Definition 2.

Original: Consider an elimination order π for a base network G .
Revised: Consider an elimination order π for a base network G .

Original: The twin elimination order π t is an elimination order for its twin network G t constructed by replacing each non-root variable X in π by X, [ X ] .
Revised: The twin elimination order π t is an elimination order for its twin network G t constructed by replacing each non-root variable X in π by X, [ X ] .

Original: Consider the base network in Figure 3b and its elimination order π = A , B , X , Y , S , C , U .
Revised: Consider the base network in Figure 3b and its elimination order π = A , B , X , Y , S , C , U .

Original: The twin elimination order will be π t =
Revised: The twin elimination order will be π t =

Original: A , [ A ] , B , [ B ] , X , Y , S , [ S ] , C , [ C ] , U .
Revised: A , [ A ] , B , [ B ] , X , Y , S , [ S ] , C , [ C ] , U .

Original: Recall that eliminating variables π ( i ) , . . .
Revised: Recall that eliminating variables π ( i ) , . . .

Original: , π ( n ) from a base network G induces a cluster sequence
Revised: , π ( n ) from a base network G induces a cluster sequence

Original: C 1 , . .
Revised: C 1 , . .

Original: . , C n .
Revised: . , C n .

Original: We use C ( X ) to denote the cluster of eliminated variable X .
Revised: We use C ( X ) to denote the cluster of eliminated variable X .

Original: Similarly, eliminating variables from a twin network G t induces a cluster sequence and we use C t ( X ) to denote the cluster of eliminated variable X and C t ([ X ]) to denote the cluster of its eliminated duplicate [ X ] .
Revised: Similarly, eliminating variables from a twin network G t induces a cluster sequence and we use C t ( X ) to denote the cluster of eliminated variable X and C t ([ X ]) to denote the cluster of its eliminated duplicate [ X ] .

Original: Theorem 1.
Revised: Theorem 1.

Original: Suppose we are eliminating variables from base network G using an elimination order π and
Revised: Suppose we are eliminating variables from base network G using an elimination order π and

Original: This theorem has two key corollaries.
Revised: This theorem has two key corollaries.

Original: The first relates the widths of an elimination order and its twin elimination order.
Revised: The first relates the widths of an elimination order and its twin elimination order.

Original: Corollary 1.
Revised: Corollary 1.

Original: Let w be the width of elimination order π for base network G and let w t be the width of twin elimination order π t for twin network G t .
Revised: Let w be the width of elimination order π for base network G and let w t be the width of twin elimination order π t for twin network G t .

Original: We then have w t ≤ 2 w + 1 .
Revised: We then have w t ≤ 2 w + 1 .

Original: The above bound is tight as shown in Appendix B.
Revised: The above bound is tight as shown in Appendix B.

Original: The next corollary gives us our first major result.
Revised: The next corollary gives us our first major result.

Original: Corollary 2.
Revised: Corollary 2.

Original: If w is the treewidth of base network G and w t is the treewidth of its twin network G t , then w t ≤ 2 w + 1 .
Revised: If w is the treewidth of base network G and w t is the treewidth of its twin network G t , then w t ≤ 2 w + 1 .

Original: 3.2 Twin jointrees
Revised: 3.2 Twin jointrees

Original: We will now provide a similar result for jointrees.
Revised: We will now provide a similar result for jointrees.

Original: That is, we will show how to convert a jointree ⟨T , H⟩ for a base network G into a jointree ⟨T t , H t ⟩ for its twin network G t while providing a guarantee on the width/size of the twin jointree in terms of the width/size of the base jointree.
Revised: That is, we will show how to convert a jointree ⟨T , H⟩ for a base network G into a jointree ⟨T t , H t ⟩ for its twin network G t while providing a guarantee on the width/size of the twin jointree in terms of the width/size of the base jointree.

Original: This may seem like a redundant result given Corollary 1 but the provided conversion will actually be critical for our later result on bounding the causal treewidth of twin networks.
Revised: This may seem like a redundant result given Corollary 1 but the provided conversion will actually be critical for our later result on bounding the causal treewidth of twin networks.

Original: It can also be significantly more efficient than constructing a jointree by operating on the (larger) twin network.
Revised: It can also be significantly more efficient than constructing a jointree by operating on the (larger) twin network.

Original: Our conversion process operates on a jointree after directing its edges away from some node r , call it a root.
Revised: Our conversion process operates on a jointree after directing its edges away from some node r , call it a root.

Original: This defines a single parent for each jointree node i ̸
Revised: This defines a single parent for each jointree node i ̸

Original: = r , which is the neighbor of i closest to root r , with all other neighbors of i being its children.
Revised: = r , which is the neighbor of i closest to root r , with all other neighbors of i being its children.

Original: These parent-child relationships are invariant when running the algorithm.
Revised: These parent-child relationships are invariant when running the algorithm.

Original: We also use a subroutine for duplicating the jointree nodes rooted at some node i .
Revised: We also use a subroutine for duplicating the jointree nodes rooted at some node i .

Original: This subroutine duplicates node i and its descendant while also duplicating the edges connecting these nodes.
Revised: This subroutine duplicates node i and its descendant while also duplicating the edges connecting these nodes.

Original: If a duplicated node j hosts a family f , this subroutine will make [ j ] host the duplicate family [ f ] (so j ∈ H ( f ) iff [ j ] ∈ H ([ f ]) ).
Revised: If a duplicated node j hosts a family f , this subroutine will make [ j ] host the duplicate family [ f ] (so j ∈ H ( f ) iff [ j ] ∈ H ([ f ]) ).

Original: [Table]
Revised: [Table]

Original: : procedure
Revised: : procedure

Original: [Table] [Table]
Revised: [Table] [Table]

Original: [Table] [Table]
Revised: [Table] [Table]

Original: [Table] [Table]
Revised: [Table] [Table]

Original: [Table]
Revised: [Table]

Original: The conversion process is given in Algorithm 1 which should be called initially with a root r that does not host a family for an internal DAG node and
Revised: The conversion process is given in Algorithm 1 which should be called initially with a root r that does not host a family for an internal DAG node and

Original: p = null .
Revised: p = null .

Original: The twin jointree in Figure 4b was obtained from the base jointree in Figure 4a by this algorithm which simply adds nodes and edges to the base jointree.
Revised: The twin jointree in Figure 4b was obtained from the base jointree in Figure 4a by this algorithm which simply adds nodes and edges to the base jointree.

Original: If an edge ( i, j ) in the base jointree is duplicated by Algorithm 1, we call ( i, j ) a duplicated edge and ([ i ] , [ j ]) a duplicate edge.
Revised: If an edge ( i, j ) in the base jointree is duplicated by Algorithm 1, we call ( i, j ) a duplicated edge and ([ i ] , [ j ]) a duplicate edge.

Original: Otherwise, we call ( i, j ) an invariant edge.
Revised: Otherwise, we call ( i, j ) an invariant edge.

Original: In Figure 4b, duplicate edges are shown in red and invariant edges are shown in green.
Revised: In Figure 4b, duplicate edges are shown in red and invariant edges are shown in green.

Original: We now have the following key result on these twin jointrees.
Revised: We now have the following key result on these twin jointrees.

Original: Theorem 2.
Revised: Theorem 2.

Original: If the input jointree to Algorithm 1 has separators S and the output jointree has separators S t , then for duplicated edges ( i, j ) , S tij = S ij ; for duplicate edges ([ i ] , [ j ]) , S t [ i ][ j ] =
Revised: If the input jointree to Algorithm 1 has separators S and the output jointree has separators S t , then for duplicated edges ( i, j ) , S tij = S ij ; for duplicate edges ([ i ] , [ j ]) , S t [ i ][ j ] =

Original: [ S ij ] ; and for invariant edges ( i, j ) , S t ij = S ij ∪ [ S ij ] .
Revised: [ S ij ] ; and for invariant edges ( i, j ) , S t ij = S ij ∪ [ S ij ] .

Original: One can verify that the separators in Figure 4 satisfy these properties.
Revised: One can verify that the separators in Figure 4 satisfy these properties.

Original: The following result bounds the width and size of twin jointrees generated by Algorithm 1.
Revised: The following result bounds the width and size of twin jointrees generated by Algorithm 1.

Original: Corollary 3.
Revised: Corollary 3.

Original: Let w be the width of a jointree for base network G and let n be the number of jointree nodes.
Revised: Let w be the width of a jointree for base network G and let n be the number of jointree nodes.

Original: Calling Algorithm 1 on this jointree will generate a jointree for twin network G t whose width is no greater than 2 w + 1 and whose number of nodes is no greater than 2 n .
Revised: Calling Algorithm 1 on this jointree will generate a jointree for twin network G t whose width is no greater than 2 w + 1 and whose number of nodes is no greater than 2 n .

Original: The above bound on width is tight as shown in Appendix B. Since treewidth can be defined in terms of jointree width, the above result leads to the same guarantee of Corollary 2 on the treewidth of twin networks.
Revised: The above bound on width is tight as shown in Appendix B. Since treewidth can be defined in terms of jointree width, the above result leads to the same guarantee of Corollary 2 on the treewidth of twin networks.

Original: However, the main role of the construction in this section is in bounding the causal treewidth of twin networks.
Revised: However, the main role of the construction in this section is in bounding the causal treewidth of twin networks.

Original: This is discussed next.
Revised: This is discussed next.

Original:  The Causal Treewidth of Twin Networks
Revised:  The Causal Treewidth of Twin Networks

Original: Recall that causal treewidth is a more refined notion than treewidth as it uses more information about the network.
Revised: Recall that causal treewidth is a more refined notion than treewidth as it uses more information about the network.

Original: In particular, this notion is relevant when we know that some variables in the
Revised: In particular, this notion is relevant when we know that some variables in the

Original: [Figure]
Revised: [Figure]

Original: [Figure]
Revised: [Figure]

Original: network are functional, without needing to know the specific functions (equations) of these variables.
Revised: network are functional, without needing to know the specific functions (equations) of these variables.

Original: By exploiting this information, one can construct thinned jointrees that have smaller separators and clusters compared to classical jointrees, which can lead to exponential savings in reasoning time [6, 11, 10].
Revised: By exploiting this information, one can construct thinned jointrees that have smaller separators and clusters compared to classical jointrees, which can lead to exponential savings in reasoning time [6, 11, 10].

Original: As mentioned earlier, the causal treewidth corresponds to the minimum width of any thinned jointree.
Revised: As mentioned earlier, the causal treewidth corresponds to the minimum width of any thinned jointree.

Original: This is guaranteed to be no greater than treewidth and can be bounded when treewidth is not [11].
Revised: This is guaranteed to be no greater than treewidth and can be bounded when treewidth is not [11].

Original: We next show that the causal treewidth of a twin network is also at most twice the causal treewidth of its base network plus one.
Revised: We next show that the causal treewidth of a twin network is also at most twice the causal treewidth of its base network plus one.

Original: We start with the following key result.
Revised: We start with the following key result.

Original: Theorem 3.
Revised: Theorem 3.

Original: Consider a twin jointree constructed by Algorithm 1 from a base jointree with thinned separators S .
Revised: Consider a twin jointree constructed by Algorithm 1 from a base jointree with thinned separators S .

Original: The following are valid thinned separators for this twin jointree: for duplicated edges ( i, j ) , S t ij = S ij ; for duplicate edges ([ i ] , [ j ]) ;
Revised: The following are valid thinned separators for this twin jointree: for duplicated edges ( i, j ) , S t ij = S ij ; for duplicate edges ([ i ] , [ j ]) ;

Original: S t [ i ][ j ] =
Revised: S t [ i ][ j ] =

Original: [ S ij ] ; and for invariant edges ( i, j ) ,
Revised: [ S ij ] ; and for invariant edges ( i, j ) ,

Original: S tij
Revised: S tij

Original: = S ij ∪ [ S ij ] .
Revised: = S ij ∪ [ S ij ] .

Original: This theorem shows that a thinned, base jointree can be automatically converted into a thinned, twin jointree.
Revised: This theorem shows that a thinned, base jointree can be automatically converted into a thinned, twin jointree.

Original: This is significant for two reasons.
Revised: This is significant for two reasons.

Original: First, this method avoids the explicit construction and thinning of jointrees for twin networks which can be quite expensive computationally [6].
Revised: First, this method avoids the explicit construction and thinning of jointrees for twin networks which can be quite expensive computationally [6].

Original: Second, we have the following guarantee on the width of thinned, twin jointrees constructed by Theorem 3.
Revised: Second, we have the following guarantee on the width of thinned, twin jointrees constructed by Theorem 3.

Original: Corollary 4.
Revised: Corollary 4.

Original: Consider the thinned, base and twin jointrees in Theorem 3.
Revised: Consider the thinned, base and twin jointrees in Theorem 3.

Original: If the thinned, base jointree has width w , then the thinned, twin jointree has width no greater than 2 w + 1 .
Revised: If the thinned, base jointree has width w , then the thinned, twin jointree has width no greater than 2 w + 1 .

Original: Figure 5a shows a thinned jointree for the base network in Figure 3b.
Revised: Figure 5a shows a thinned jointree for the base network in Figure 3b.

Original: Figure 5b shows the corresponding thinned, twin jointree constructed by Algorithm 1 and annotated with the thinned separators (and clusters) as given by Theorem 3.
Revised: Figure 5b shows the corresponding thinned, twin jointree constructed by Algorithm 1 and annotated with the thinned separators (and clusters) as given by Theorem 3.

Original: We can now bound the causal treewidth of twin networks.
Revised: We can now bound the causal treewidth of twin networks.

Original: Corollary 5.
Revised: Corollary 5.

Original: If w and w t are the causal treewidths of a base network and its twin network, then w t ≤ 2 w + 1 .
Revised: If w and w t are the causal treewidths of a base network and its twin network, then w t ≤ 2 w + 1 .

Original:  Counterfactual Reasoning Beyond Two Worlds
Revised:  Counterfactual Reasoning Beyond Two Worlds

Original: Standard counterfactual reasoning contemplates two worlds, one real and another imaginary, while assuming that root nodes of the base network (exogenous variables) correspond to causal mechanisms that govern both worlds.
Revised: Standard counterfactual reasoning contemplates two worlds, one real and another imaginary, while assuming that root nodes of the base network (exogenous variables) correspond to causal mechanisms that govern both worlds.

Original: This motivates the notion of a twin network as it ensures that these causal mechanisms are invariant.
Revised: This motivates the notion of a twin network as it ensures that these causal mechanisms are invariant.

Original: This type of reasoning can be thought of as a special case of temporal reasoning where variables change their states over time.
Revised: This type of reasoning can be thought of as a special case of temporal reasoning where variables change their states over time.

Original: In standard counterfactual reasoning, only endogenous variables can change their states over time and we only have two time steps corresponding to the real and imaginary worlds.
Revised: In standard counterfactual reasoning, only endogenous variables can change their states over time and we only have two time steps corresponding to the real and imaginary worlds.

Original: A more general setup arises when we relax these assumptions.
Revised: A more general setup arises when we relax these assumptions.

Original: That is, we allow multiple time steps (worlds) and we allow some exogenous variables to also change their states over time.
Revised: That is, we allow multiple time steps (worlds) and we allow some exogenous variables to also change their states over time.

Original: For an example of this, consider again the half adder in Figure 3a and its base network in Figure 4c.
Revised: For an example of this, consider again the half adder in Figure 3a and its base network in Figure 4c.

Original: Suppose we set inputs A and B to high and low and observe outputs S and C to be high and low as well, which is a normal behavior.
Revised: Suppose we set inputs A and B to high and low and observe outputs S and C to be high and low as well, which is a normal behavior.

Original: We then set both inputs to low and observe that the outputs do not change, which is an abnormal behavior.
Revised: We then set both inputs to low and observe that the outputs do not change, which is an abnormal behavior.

Original: We then aim to predict the state of outputs if we were to set both inputs to high.
Revised: We then aim to predict the state of outputs if we were to set both inputs to high.

Original: This scenario involves three time steps (worlds).
Revised: This scenario involves three time steps (worlds).

Original: Moreover, while the health of gates X and Y are invariant over time, we do not wish to make the same assumption about the inputs A and B .
Revised: Moreover, while the health of gates X and Y are invariant over time, we do not wish to make the same assumption about the inputs A and B .

Original: We can model this situation using the network in Figure 4c, which is not a twin network but a more general type of networks that appears quite frequently in practice.
Revised: We can model this situation using the network in Figure 4c, which is not a twin network but a more general type of networks that appears quite frequently in practice.

Original: We call these N -world networks.
Revised: We call these N -world networks.

Original: Definition 3.
Revised: Definition 3.

Original: Consider a base network G and let R be a subset of its roots and N ≥ 1 be an integer.
Revised: Consider a base network G and let R be a subset of its roots and N ≥ 1 be an integer.

Original: The N -world network G N of G is constructed as follows.
Revised: The N -world network G N of G is constructed as follows.

Original: For each variable X in G that is not in R , replace it with N duplicates of X , labeled X 1 , X 2 , . .
Revised: For each variable X in G that is not in R , replace it with N duplicates of X , labeled X 1 , X 2 , . .

Original: X N .
Revised: X N .

Original: For each parent P of X , if P is in R , make P a parent of X i for all i ∈ 1 , 2 , . . .
Revised: For each parent P of X , if P is in R , make P a parent of X i for all i ∈ 1 , 2 , . . .

Original: , N .
Revised: , N .

Original: Else, make P i a parent of X i for all i ∈ 1 , 2 , . . .
Revised: Else, make P i a parent of X i for all i ∈ 1 , 2 , . . .

Original: , N .
Revised: , N .

Original: This definition generalizes the notion of a parallel worlds model [1] which falls as a special case when R contains all roots in the base network.
Revised: This definition generalizes the notion of a parallel worlds model [1] which falls as a special case when R contains all roots in the base network.

Original: Moreover, twin networks fall as a special case of this definition when N = 2 and R contains all roots of the base network.
Revised: Moreover, twin networks fall as a special case of this definition when N = 2 and R contains all roots of the base network.

Original: The question now is: can we provide guarantees on the (causal) treewidth of N -world networks in terms of the (causal) treewidth of their base networks?
Revised: The question now is: can we provide guarantees on the (causal) treewidth of N -world networks in terms of the (causal) treewidth of their base networks?

Original: The answer is yes as shown by the following generalization of earlier results.
Revised: The answer is yes as shown by the following generalization of earlier results.

Original: Theorem 4.
Revised: Theorem 4.

Original: If w and w t are the (causal) treewidths of a base network and its N -world network, then w t ≤ N ( w + 1) − 1 .
Revised: If w and w t are the (causal) treewidths of a base network and its N -world network, then w t ≤ N ( w + 1) − 1 .

Original: The class of N -world networks can be viewed as a subclass of dynamic Bayesian networks [14] and is significant for a number of reasons.
Revised: The class of N -world networks can be viewed as a subclass of dynamic Bayesian networks [14] and is significant for a number of reasons.

Original: First, as illustrated by the above example, it arises when reasoning about the behavior of systems consisting of function blocks (e.g., gates) where each block has a health state that dictates its behavior and is invariant over time.
Revised: First, as illustrated by the above example, it arises when reasoning about the behavior of systems consisting of function blocks (e.g., gates) where each block has a health state that dictates its behavior and is invariant over time.

Original: This covers a large class of applications, particularly in model-based diagnosis [20].
Revised: This covers a large class of applications, particularly in model-based diagnosis [20].

Original: Further, the class of N -world networks allows counterfactual reasoning where conflicting observations and actions can arise in multiple worlds [27].
Revised: Further, the class of N -world networks allows counterfactual reasoning where conflicting observations and actions can arise in multiple worlds [27].

Original: Consider a treatment regime that may be administered daily where its outcomes are also measured daily.
Revised: Consider a treatment regime that may be administered daily where its outcomes are also measured daily.

Original: One may have observations and interventions that cover a number of days and wishes to predict the result of an intervention on the following day.
Revised: One may have observations and interventions that cover a number of days and wishes to predict the result of an intervention on the following day.

Original: This can be achieved using N -world networks.
Revised: This can be achieved using N -world networks.

Original: See [1, 38, 39] for additional, more sophisticated uses of N -world networks.
Revised: See [1, 38, 39] for additional, more sophisticated uses of N -world networks.

Original:  Counterfactual Reasoning with Partially Specified SCMs
Revised:  Counterfactual Reasoning with Partially Specified SCMs

Original: The results we presented on N -world networks, which include twin networks, apply directly to fully specified SCMs.
Revised: The results we presented on N -world networks, which include twin networks, apply directly to fully specified SCMs.

Original: In particular, in the context of variable elimination and jointree algorithms, these results allow us to bound the complexity of computing counterfactual queries in terms of the complexity of computing associational/interventional queries.
Revised: In particular, in the context of variable elimination and jointree algorithms, these results allow us to bound the complexity of computing counterfactual queries in terms of the complexity of computing associational/interventional queries.

Original: Moreover, they provide efficient methods for constructing elimination orders and jointrees that can be used for computing counterfactual queries based on the ones used for answering associational/interventional queries, while ensuring that the stated bounds will be realized.
Revised: Moreover, they provide efficient methods for constructing elimination orders and jointrees that can be used for computing counterfactual queries based on the ones used for answering associational/interventional queries, while ensuring that the stated bounds will be realized.

Original: Recall again that our bounds and constructions apply to both traditional treewidth (jointrees) and the more recent causal treewidth (thinned jointrees).
Revised: Recall again that our bounds and constructions apply to both traditional treewidth (jointrees) and the more recent causal treewidth (thinned jointrees).

Original: Causal reasoning can also be conducted using partially specified SCMs and data.
Revised: Causal reasoning can also be conducted using partially specified SCMs and data.

Original: A partially specified
Revised: A partially specified

Original: SCM typically includes the SCM structure and some information about its parameters.
Revised: SCM typically includes the SCM structure and some information about its parameters.

Original: For example, we may not know any of the SCM paramaters, or we may only know the structural equations but not the distributions over exogenous variables.
Revised: For example, we may not know any of the SCM paramaters, or we may only know the structural equations but not the distributions over exogenous variables.

Original: A central question in this setup is whether the
Revised: A central question in this setup is whether the

Original: [Figure]
Revised: [Figure]

Original: available information, which includes data, is sufficient to obtain a point estimate for the causal query of interest, in which case the query is said to be identifiable.
Revised: available information, which includes data, is sufficient to obtain a point estimate for the causal query of interest, in which case the query is said to be identifiable.

Original: A significant amount of work on causality has focused on characterizing conditions under which causal queries (both counterfactual and interventional) are identifiable; see, [32, 40] for textbook discussions of this subject and [39, 7] for some results on the identification of counterfactual queries.
Revised: A significant amount of work on causality has focused on characterizing conditions under which causal queries (both counterfactual and interventional) are identifiable; see, [32, 40] for textbook discussions of this subject and [39, 7] for some results on the identification of counterfactual queries.

Original: When a query is identifiable, the classical approach for estimating it is to derive an estimand using techniques such as the do-calculus for interventional queries [30, 42, 37].
Revised: When a query is identifiable, the classical approach for estimating it is to derive an estimand using techniques such as the do-calculus for interventional queries [30, 42, 37].

Original: Some recent approaches take a different direction such as reducing the estimation of queries to a constrained optimization problem [16].
Revised: Some recent approaches take a different direction such as reducing the estimation of queries to a constrained optimization problem [16].

Original: Yet another recent direction is to first estimate the SCM parameters which yields a fully specified SCM that is then used to answer (identifiable) interventional and counterfactual queries using classical inference algorithms [45, 44, 11].
Revised: Yet another recent direction is to first estimate the SCM parameters which yields a fully specified SCM that is then used to answer (identifiable) interventional and counterfactual queries using classical inference algorithms [45, 44, 11].

Original: 4 Our results on twin and N -world networks apply directly in this case as they can be used when conducting inference on the fully parameterized SCM.
Revised: 4 Our results on twin and N -world networks apply directly in this case as they can be used when conducting inference on the fully parameterized SCM.

Original: When the causal query is not identifiable, the classical approach is to derive a closed-form bound on the query; see, for example, [2, 31, 41, 13, 36, 17, 46, 28, 47].
Revised: When the causal query is not identifiable, the classical approach is to derive a closed-form bound on the query; see, for example, [2, 31, 41, 13, 36, 17, 46, 28, 47].

Original: Some recent approaches establish (approximate) bounds by estimating SCM parameters and then using classical inference algorithms on the fully specified SCM to obtain point estimates [45, 44].
Revised: Some recent approaches establish (approximate) bounds by estimating SCM parameters and then using classical inference algorithms on the fully specified SCM to obtain point estimates [45, 44].

Original: Since the query is not identifiable, different parametrizations can lead to different point estimates which are employed to improve the computed bounds.
Revised: Since the query is not identifiable, different parametrizations can lead to different point estimates which are employed to improve the computed bounds.

Original: Our results can also be used in this case for computing point estimates based on a particular parametrization (fully specified SCM) within the overall process of establishing bounds.
Revised: Our results can also be used in this case for computing point estimates based on a particular parametrization (fully specified SCM) within the overall process of establishing bounds.

Original:  Experimental Results
Revised:  Experimental Results

Original: We consider experiments in this section that target random networks whose structures emulate the structures of SCMs used in counterfactual reasoning.
Revised: We consider experiments in this section that target random networks whose structures emulate the structures of SCMs used in counterfactual reasoning.

Original: We have a few objectives in mind.
Revised: We have a few objectives in mind.

Original: First, we wish to compare the widths of base and twin jointrees, with and without thinning.
Revised: First, we wish to compare the widths of base and twin jointrees, with and without thinning.

Original: These widths do not correspond to (causal) treewidth since the jointrees are constructed using heuristics (finding optimal jointrees is NP-hard).
Revised: These widths do not correspond to (causal) treewidth since the jointrees are constructed using heuristics (finding optimal jointrees is NP-hard).

Original: Next, we want to compare the quality of twin jointrees constructed by
Revised: Next, we want to compare the quality of twin jointrees constructed by

Original: Algorithm 1 (TWIN-ALG1), which operates directly on a base jointree, to the quality of twin jointrees obtained by applying the minfill heuristic to a twin network (TWIN-MF).
Revised: Algorithm 1 (TWIN-ALG1), which operates directly on a base jointree, to the quality of twin jointrees obtained by applying the minfill heuristic to a twin network (TWIN-MF).

Original: Recall that the former method is more efficient than the latter method.
Revised: Recall that the former method is more efficient than the latter method.

Original: Finally, we wish to conduct a similar comparison between the thinned, twin jointrees constructed according to Theorem 3 (TWIN-THM3) and the thinned, twin jointrees obtained by applying the minfill heuristic and thinning rules to a twin network (TWIN-MF-RLS).
Revised: Finally, we wish to conduct a similar comparison between the thinned, twin jointrees constructed according to Theorem 3 (TWIN-THM3) and the thinned, twin jointrees obtained by applying the minfill heuristic and thinning rules to a twin network (TWIN-MF-RLS).

Original: Again, the former method is more efficient than the latter.
Revised: Again, the former method is more efficient than the latter.

Original: The widths of these jointrees will be compared to the widths of base jointrees constructed by minfill (BASE-MF) and thinned, base jointrees constructed by minfill and thinning rules (BASE-MF-RLS).
Revised: The widths of these jointrees will be compared to the widths of base jointrees constructed by minfill (BASE-MF) and thinned, base jointrees constructed by minfill and thinning rules (BASE-MF-RLS).

Original: We generated random networks according to the method used in [10].
Revised: We generated random networks according to the method used in [10].

Original: Given a number of nodes n and a maximum number of parents p , the method chooses the parents of node X i randomly from the set X 1 , . . .
Revised: Given a number of nodes n and a maximum number of parents p , the method chooses the parents of node X i randomly from the set X 1 , . . .

Original: , X i − 1 .
Revised: , X i − 1 .

Original: The number of parents for node X i is chosen randomly from the set 0 , . .
Revised: The number of parents for node X i is chosen randomly from the set 0 , . .

Original: , min ( p, i − 1) .
Revised: , min ( p, i − 1) .

Original: We refer to these networks as rNET.
Revised: We refer to these networks as rNET.

Original: We then consider each internal node N and add a unique root R as parent for N .
Revised: We then consider each internal node N and add a unique root R as parent for N .

Original: This is meant to emulate the structure of SCMs as the exogenous variable R can be viewed as representing the different causal mechanisms for endogenous variable N .
Revised: This is meant to emulate the structure of SCMs as the exogenous variable R can be viewed as representing the different causal mechanisms for endogenous variable N .

Original: We refer to these modified networks as rSCM.
Revised: We refer to these modified networks as rSCM.

Original: The twin networks of rSCM are more complex than those for rNET since more variables are shared between the two slices representing the real and imaginary worlds (i.e., more information is shared between the two worlds).
Revised: The twin networks of rSCM are more complex than those for rNET since more variables are shared between the two slices representing the real and imaginary worlds (i.e., more information is shared between the two worlds).

Original: We used n ∈ { 50 , 75 , 100 , 125 , 150 , 200 , 250 , 300 } and p ∈ { 3 , 5 , 7 } .
Revised: We used n ∈ { 50 , 75 , 100 , 125 , 150 , 200 , 250 , 300 } and p ∈ { 3 , 5 , 7 } .

Original: For each combination of n and p , we generated 50 random, base networks and reported averages of two properties for the constructed jointrees: width and normalized width.
Revised: For each combination of n and p , we generated 50 random, base networks and reported averages of two properties for the constructed jointrees: width and normalized width.

Original: If a jointree has clusters C 1 , . . .
Revised: If a jointree has clusters C 1 , . . .

Original: , C n , then normalized width is log 2 (cid:80) ni
Revised: , C n , then normalized width is log 2 (cid:80) ni

Original: =1 2 | C i | .
Revised: =1 2 | C i | .

Original: This accounts for all clusters in the jointree instead of just the largest one (it also accounts for the jointree size).
Revised: This accounts for all clusters in the jointree instead of just the largest one (it also accounts for the jointree size).

Original: The data we generated occupies significant space so we included it in Appendix C while providing representative plots in Figure 6 for jointree widths under p = 5 .
Revised: The data we generated occupies significant space so we included it in Appendix C while providing representative plots in Figure 6 for jointree widths under p = 5 .

Original: We next discuss patterns exhibited in these plots and the full data in Appendix C, which also includes experiments using random networks generated according to the method in [21].
Revised: We next discuss patterns exhibited in these plots and the full data in Appendix C, which also includes experiments using random networks generated according to the method in [21].

Original: First, the widths of twin jointrees are always less than twice the widths of their base jointrees and often significantly less than that.
Revised: First, the widths of twin jointrees are always less than twice the widths of their base jointrees and often significantly less than that.

Original: This is not guaranteed by our theoretical bounds as those apply to (causal) treewidth not to the widths of jointrees produced by heuristics — the latter widths are an upper bound on the former.
Revised: This is not guaranteed by our theoretical bounds as those apply to (causal) treewidth not to the widths of jointrees produced by heuristics — the latter widths are an upper bound on the former.

Original: Second, constructing a twin jointree by directly applying Algorithm 1 to a base jointree (TWIN-ALG1) is relatively comparable to constructing the twin jointree by operating on the twin network (TWIN-MF), as would normally be done.
Revised: Second, constructing a twin jointree by directly applying Algorithm 1 to a base jointree (TWIN-ALG1) is relatively comparable to constructing the twin jointree by operating on the twin network (TWIN-MF), as would normally be done.

Original: This also holds for thinned jointrees (TWIN-THM3 vs TWIN-MF-RLS) and is encouraging since the former methods are much more efficient than the latter ones.
Revised: This also holds for thinned jointrees (TWIN-THM3 vs TWIN-MF-RLS) and is encouraging since the former methods are much more efficient than the latter ones.

Original: Third, the employment of thinned jointrees can lead to significant reduction in width and hence an exponential reduction in reasoning time.
Revised: Third, the employment of thinned jointrees can lead to significant reduction in width and hence an exponential reduction in reasoning time.

Original: This can be seen by comparing the widths of twin jointrees TWIN-THM3 and TWIN-ALG1 since the former is thinned but the latter is not (similarly for TWIN-MF-RLS and TWIN-MF).
Revised: This can be seen by comparing the widths of twin jointrees TWIN-THM3 and TWIN-ALG1 since the former is thinned but the latter is not (similarly for TWIN-MF-RLS and TWIN-MF).

Original: Fourth, the twin jointrees of rSCM have larger widths than those of rNET.
Revised: Fourth, the twin jointrees of rSCM have larger widths than those of rNET.

Original: Recall that in rSCM, every endogenous variable has its own exogenous variable as a parent.
Revised: Recall that in rSCM, every endogenous variable has its own exogenous variable as a parent.

Original: Therefore, the distribution over exogenous variables has a larger space in rSCM compared to rNET.
Revised: Therefore, the distribution over exogenous variables has a larger space in rSCM compared to rNET.

Original: Since this distribution needs to be shared between the real and imaginary worlds, counterfactual reasoning with rSCM is indeed expected to be more complex computationally than reasoning with rNET.
Revised: Since this distribution needs to be shared between the real and imaginary worlds, counterfactual reasoning with rSCM is indeed expected to be more complex computationally than reasoning with rNET.

Original: Finally, consider Figure 6b for a bottom-line comparison between the complexity of counterfactual reasoning and the complexity of associational/interventional reasoning in practice.
Revised: Finally, consider Figure 6b for a bottom-line comparison between the complexity of counterfactual reasoning and the complexity of associational/interventional reasoning in practice.

Original: Jointrees BASE-MF have the smallest widths for base networks so these are the jointrees one would use for associational/interventional reasoning.
Revised: Jointrees BASE-MF have the smallest widths for base networks so these are the jointrees one would use for associational/interventional reasoning.

Original: The best twin jointrees are TWIN-MF-RLS which are thinned.
Revised: The best twin jointrees are TWIN-MF-RLS which are thinned.

Original: This is what one would use for counterfactual reasoning.
Revised: This is what one would use for counterfactual reasoning.

Original: The widths of latter jointrees are always less than twice the widths of the former, and quite often significantly much less.
Revised: The widths of latter jointrees are always less than twice the widths of the former, and quite often significantly much less.

Original:  Conclusion
Revised:  Conclusion

Original: We studied the complexity of counterfactual reasoning on fully specified SCMs in relation to the complexity of associational and interventional reasoning on these models.
Revised: We studied the complexity of counterfactual reasoning on fully specified SCMs in relation to the complexity of associational and interventional reasoning on these models.

Original: Our basic finding is that in the context of algorithms based on (causal) treewidth, the former complexity is no greater than quadratic in the latter when counterfactual reasoning involves only two worlds.
Revised: Our basic finding is that in the context of algorithms based on (causal) treewidth, the former complexity is no greater than quadratic in the latter when counterfactual reasoning involves only two worlds.

Original: We extended these results to counterfactual reasoning that requires multiple worlds, showing that the gap in complexity is bounded polynomially by the number of needed worlds.
Revised: We extended these results to counterfactual reasoning that requires multiple worlds, showing that the gap in complexity is bounded polynomially by the number of needed worlds.

Original: Our empirical results suggest that for two types of random SCMs, the complexity of counterfactual reasoning is closer to that of associational and interventional reasoning than our worst-case theoretical analysis may suggest.
Revised: Our empirical results suggest that for two types of random SCMs, the complexity of counterfactual reasoning is closer to that of associational and interventional reasoning than our worst-case theoretical analysis may suggest.

Original: While our results directly target counterfactual reasoning on fully specified SCMs, we also discussed cases when they can be applied to counterfactual reasoning on partially specified SCMs that are coupled with data.
Revised: While our results directly target counterfactual reasoning on fully specified SCMs, we also discussed cases when they can be applied to counterfactual reasoning on partially specified SCMs that are coupled with data.

Original: Acknowledgements
Revised: Acknowledgements

Original: We wish to thank Haiying Huang and Scott Mueller for providing useful feedback on an earlier version of this paper.
Revised: We wish to thank Haiying Huang and Scott Mueller for providing useful feedback on an earlier version of this paper.

Original: This work has been partially supported by ONR grant N
Revised: This work has been partially supported by ONR grant N

Original: Checklist

Original: all authors... (a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope?

Original: [Yes] (b) Did you describe the limitations of your work?

Original: [N/A] (c) Did you discuss any potential negative societal impacts of your work?

Original: [N/A] (d) Have you read the ethics review guidelines and ensured that your paper conforms to them?

Original: [Yes] 2.

Original: If you are including theoretical results... (a) Did you state the full set of assumptions of all theoretical results?

Original: [Yes] (b) Did you include complete proofs of all theoretical results?

Original: [Yes] 3.

Original: If you ran experiments... (a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)?

Original: [No] (b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)?

Original: [N/A] (c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)?

Original: [N/A] (d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)?

Original: [Yes] 4.

Original: If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... (a) If your work uses existing assets, did you cite the creators?

Original: [N/A] (b) Did you mention the license of the assets?

Original: [N/A]

Original: (c) Did you include any new assets either in the supplemental material or as a URL?

Original: [N/A] (d) Did you discuss whether

Original: and how consent was obtained from people whose data you’re using/curating?

Original: [N/A] (e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content?

Original: [N/A] 5.

Original: If you used crowdsourcing or conducted research with human subjects... (a) Did you include the full text of instructions given to participants and screenshots, if applicable?

Original: [N/A] (b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable?

Original: [N/A] (c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation?

Original: [N/A]

Original: A Proofs Proof of Theorem
Revised: A Proofs Proof of Theorem

Original: Consider a base network G and its twin network G t .
Revised: Consider a base network G and its twin network G t .

Original: We first introduce a set notation { X, [ X ] } , which contains both the base and duplicate variable for X if X is an internal variable and collapses to a single variable if X is a root variable.
Revised: We first introduce a set notation { X, [ X ] } , which contains both the base and duplicate variable for X if X is an internal variable and collapses to a single variable if X is a root variable.

Original: For an elimination order π on a base network G , [9] defines a graph sequence G 1 , G 2 , . .
Revised: For an elimination order π on a base network G , [9] defines a graph sequence G 1 , G 2 , . .

Original: G n induced by π , where G 1 is the moral graph for G , and G i +1 is the result of eliminating π ( i ) from
Revised: G n induced by π , where G 1 is the moral graph for G , and G i +1 is the result of eliminating π ( i ) from

Original: G i .
Revised: G i .

Original: Similarly, we define a twin graph sequence G t 1 , G t 2 , . . .
Revised: Similarly, we define a twin graph sequence G t 1 , G t 2 , . . .

Original: , G tn , where G t 1 is the moral graph for
Revised: , G tn , where G t 1 is the moral graph for

Original: G t , and G ti +1 is the result of eliminating { π ( i ) , [ π ( i )] } from G ti .
Revised: G t , and G ti +1 is the result of eliminating { π ( i ) , [ π ( i )] } from G ti .

Original: Consider G i in the graph sequence induced by π on G .
Revised: Consider G i in the graph sequence induced by π on G .

Original: For each variable X in G i , let G i ( X ) be the set consisting of X and its neighbors in G i .
Revised: For each variable X in G i , let G i ( X ) be the set consisting of X and its neighbors in G i .

Original: Similarly, let G ti ( X ) and G ti ([ X ]) denote the set consisting of X and its neighbors, and the set consisting of [ X ] and its neighbors in G ti , respectively.
Revised: Similarly, let G ti ( X ) and G ti ([ X ]) denote the set consisting of X and its neighbors, and the set consisting of [ X ] and its neighbors in G ti , respectively.

Original: By definition, G i ( π ( i ))
Revised: By definition, G i ( π ( i ))

Original: =
Revised: =

Original: C ( π ( i )) and G ti ( π ( i )) =
Revised: C ( π ( i )) and G ti ( π ( i )) =

Original: C t ( π ( i )) .
Revised: C t ( π ( i )) .

Original: We first propose a Lemma that relates G ti ( X ) and G i ( X ) .
Revised: We first propose a Lemma that relates G ti ( X ) and G i ( X ) .

Original: Lemma 1.
Revised: Lemma 1.

Original: Suppose we apply elimination order π to a base network G and apply π t to its twin network G t .
Revised: Suppose we apply elimination order π to a base network G and apply π t to its twin network G t .

Original: Then for each variable X in G i , we have G ti ( X ) ⊆
Revised: Then for each variable X in G i , we have G ti ( X ) ⊆

Original: G i ( X ) ∪ [ G i ( X )] and G ti ([ X ]) ⊆
Revised: G i ( X ) ∪ [ G i ( X )] and G ti ([ X ]) ⊆

Original: G i ( X ) ∪ [ G i ( X )] .
Revised: G i ( X ) ∪ [ G i ( X )] .

Original: Proof.
Revised: Proof.

Original: We will prove this by induction on G ti .
Revised: We will prove this by induction on G ti .

Original: The statement holds initially for G t 1 by the definition of twin networks.
Revised: The statement holds initially for G t 1 by the definition of twin networks.

Original: Suppose the statement holds for G ti − 1 , i.e. G ti − 1 ( X ) ⊆
Revised: Suppose the statement holds for G ti − 1 , i.e. G ti − 1 ( X ) ⊆

Original: G i − 1 ( X ) ∪ [ G i − 1 ( X )] and
Revised: G i − 1 ( X ) ∪ [ G i − 1 ( X )] and

Original: G ti − 1 ([ X ]) ⊆
Revised: G ti − 1 ([ X ]) ⊆

Original: G i − 1 ( X ) ∪ [ G i − 1 ( X )] for every { X, [ X ] } in G ti − 1 , we need to show the statement holds for G ti .
Revised: G i − 1 ( X ) ∪ [ G i − 1 ( X )] for every { X, [ X ] } in G ti − 1 , we need to show the statement holds for G ti .

Original: For simplicity, let Y denote the variable being eliminated at step i , i.e. Y =
Revised: For simplicity, let Y denote the variable being eliminated at step i , i.e. Y =

Original: π ( i − 1) .
Revised: π ( i − 1) .

Original: WLG, consider each base variable X in G ti (similar argument can be applied to each duplicate variable [ X ] ).
Revised: WLG, consider each base variable X in G ti (similar argument can be applied to each duplicate variable [ X ] ).

Original: G ti ( X ) is affected by the elimination of { Y, [ Y ] } iff X is a neighbor of { Y, [ Y ] } in G ti − 1 .
Revised: G ti ( X ) is affected by the elimination of { Y, [ Y ] } iff X is a neighbor of { Y, [ Y ] } in G ti − 1 .

Original: Moreover, by induction, X is a neighbor of { Y, [ Y ] } in G ti − 1 only if X is a neighbor of Y in G i − 1 .
Revised: Moreover, by induction, X is a neighbor of { Y, [ Y ] } in G ti − 1 only if X is a neighbor of Y in G i − 1 .

Original: When X is not a neighbor of Y , then G ti ( X ) =
Revised: When X is not a neighbor of Y , then G ti ( X ) =

Original: G ti − 1 ( X ) and G i ( X ) =
Revised: G ti − 1 ( X ) and G i ( X ) =

Original: G i − 1 ( X ) , so the statement holds.
Revised: G i − 1 ( X ) , so the statement holds.

Original: When X is a neighbor of Y , G i ( X )
Revised: When X is a neighbor of Y , G i ( X )

Original: =
Revised: =

Original: G i − 1 ( X ) ∪ G i − 1 ( Y ) \ { Y } by the definition of variable elimination.
Revised: G i − 1 ( X ) ∪ G i − 1 ( Y ) \ { Y } by the definition of variable elimination.

Original: We can then bound G ti ( X ) as follows:
Revised: We can then bound G ti ( X ) as follows:

Original: [Equation]
Revised: [Equation]

Original: hypothesis
Revised: hypothesis

Original: [Equation]
Revised: [Equation]

Original: Proof for Theorem 1. Consider each variable X that is eliminated at step i , i.e. X
Revised: Proof for Theorem 1. Consider each variable X that is eliminated at step i , i.e. X

Original: = π
Revised: = π

Original: ( i ) .
Revised: ( i ) .

Original: By
Revised: By

Original: Lemma 1, C t ( X ) =
Revised: Lemma 1, C t ( X ) =

Original: G ti − 1 ( X ) ⊆
Revised: G ti − 1 ( X ) ⊆

Original: G i − 1 ( X ) ∪ [ G i − 1 ( X )]
Revised: G i − 1 ( X ) ∪ [ G i − 1 ( X )]

Original: = C ( X ) ∪ [ C ( X )] .
Revised: = C ( X ) ∪ [ C ( X )] .

Original: We next bound C t ([ X ]) if X is an internal variable,
Revised: We next bound C t ([ X ]) if X is an internal variable,

Original: [Equation]
Revised: [Equation]

Original: eliminating X from G t
Revised: eliminating X from G t

Original: i
Revised: i

Original: [Equation] [Equation]
Revised: [Equation] [Equation]

Original: (by Lemma 1) ⊆
Revised: (by Lemma 1) ⊆

Original: [Equation]
Revised: [Equation]

Original: Proof for Corollary 1.
Revised: Proof for Corollary 1.

Original: By Theorem 1, for every base variable X ∈ G t , | C t ( X ) | ≤ | C ( X ) ∪ [ C ( X )] | ≤ 2 | C ( X ) | .
Revised: By Theorem 1, for every base variable X ∈ G t , | C t ( X ) | ≤ | C ( X ) ∪ [ C ( X )] | ≤ 2 | C ( X ) | .

Original: Similarly, for every duplicate variable [ X ] ∈ G t , | C t ([ X ]) | ≤ | C
Revised: Similarly, for every duplicate variable [ X ] ∈ G t , | C t ([ X ]) | ≤ | C

Original: ( X ) ∪ [ C ( X )] | ≤ 2 | C ( X ) | .
Revised: ( X ) ∪ [ C ( X )] | ≤ 2 | C ( X ) | .

Original: So w t = max X ∈ G t | C t ( X ) |− 1 ≤ 2 max X ∈ G | C ( X ) |− 1 = 2( w +1) − 1 = 2 w + 1 .
Revised: So w t = max X ∈ G t | C t ( X ) |− 1 ≤ 2 max X ∈ G | C ( X ) |− 1 = 2( w +1) − 1 = 2 w + 1 .

Original: Proof for Corollary 2.
Revised: Proof for Corollary 2.

Original: Consider an optimal elimination order π for base network G with width w .
Revised: Consider an optimal elimination order π for base network G with width w .

Original: By Corollary 1, the twin elimination order for G t with width no more than 2 w + 1 .
Revised: By Corollary 1, the twin elimination order for G t with width no more than 2 w + 1 .

Original: It follows that the treewidth of G t is no more than 2 w + 1 .
Revised: It follows that the treewidth of G t is no more than 2 w + 1 .

Original: Proof of Theorem
Revised: Proof of Theorem

Original: We first state a key observation from Algorithm 1, which is formulated as Lemma 2.
Revised: We first state a key observation from Algorithm 1, which is formulated as Lemma 2.

Original: For simplicity, we say a leaf node hosts variable X
Revised: For simplicity, we say a leaf node hosts variable X

Original: if it hosts a family that contains X .
Revised: if it hosts a family that contains X .

Original: Lemma 2.
Revised: Lemma 2.

Original: Consider each invariant edge ( i, j ) in a twin jointree constructed from Algorithm 1.
Revised: Consider each invariant edge ( i, j ) in a twin jointree constructed from Algorithm 1.

Original: A variable X is hosted in some leaf on the i -side of the edge iff [ X ] is also hosted in some leaf on the i -side of the edge.
Revised: A variable X is hosted in some leaf on the i -side of the edge iff [ X ] is also hosted in some leaf on the i -side of the edge.

Original: Proof.
Revised: Proof.

Original: If X is a root variable, then X =
Revised: If X is a root variable, then X =

Original: [ X ] and the lemma holds.
Revised: [ X ] and the lemma holds.

Original: Now suppose X is an internal variable.
Revised: Now suppose X is an internal variable.

Original: Let k be the leaf node on the i -side of the edge that hosts X , it suffices to show that k is duplicated into a [ k ] on the i -side that hosts [ X ] .
Revised: Let k be the leaf node on the i -side of the edge that hosts X , it suffices to show that k is duplicated into a [ k ] on the i -side that hosts [ X ] .

Original: Since X is an internal variable, k hosts either the family for X or a family for some child of X .
Revised: Since X is an internal variable, k hosts either the family for X or a family for some child of X .

Original: In either case, k hosts a family for an internal variable.
Revised: In either case, k hosts a family for an internal variable.

Original: Moreover, k is contained in some subtree rooted at u whose leaves host only families for internal variables.
Revised: Moreover, k is contained in some subtree rooted at u whose leaves host only families for internal variables.

Original: Since k is on the i -side of the invariant edge ( i, j ) , u is also on the i -side of the edge.
Revised: Since k is on the i -side of the invariant edge ( i, j ) , u is also on the i -side of the edge.

Original: Hence the duplicate leaf [ k ] , which hosts [ X ] , is also on the i -side of the edge.
Revised: Hence the duplicate leaf [ k ] , which hosts [ X ] , is also on the i -side of the edge.

Original: Conversely, suppose [ X ] is hosted by some leaf [ k ] on the
Revised: Conversely, suppose [ X ] is hosted by some leaf [ k ] on the

Original: i -side of edge ( i, j ) , then [ k ] hosts some family for a duplicate variable.
Revised: i -side of edge ( i, j ) , then [ k ] hosts some family for a duplicate variable.

Original: [ k ] is contained in some duplicate subtree rooted at [ u ] whose leaves only host families for duplicate variables.
Revised: [ k ] is contained in some duplicate subtree rooted at [ u ] whose leaves only host families for duplicate variables.

Original: It follows that the base subtree rooted at u is located on the i -side of the edge and contains a base node k hosting X .
Revised: It follows that the base subtree rooted at u is located on the i -side of the edge and contains a base node k hosting X .

Original: We first recall the definition of separators: X ∈ S ij if and only if X is hosted on both sides of the edge ( i, j ) .
Revised: We first recall the definition of separators: X ∈ S ij if and only if X is hosted on both sides of the edge ( i, j ) .

Original: For simplicity, we use vars ( i, j ) to denote the variables that appear on the i -side of the edge ( i, j ) in the base jointree.
Revised: For simplicity, we use vars ( i, j ) to denote the variables that appear on the i -side of the edge ( i, j ) in the base jointree.

Original: Similarly, we use vars t ( i, j ) and to denote the variables that appear on the i -side in the twin jointree.
Revised: Similarly, we use vars t ( i, j ) and to denote the variables that appear on the i -side in the twin jointree.

Original: By definition, for each edge ( i, j ) , S ij = vars ( i, j ) ∩ vars ( j, i ) and S tij = vars t ( i, j ) ∩ vars t ( j, i ) .
Revised: By definition, for each edge ( i, j ) , S ij = vars ( i, j ) ∩ vars ( j, i ) and S tij = vars t ( i, j ) ∩ vars t ( j, i ) .

Original: Given a jointree and its root, we say that a jointree node j is above a jointree node i if j is closer to the root than i , and that j is below i if j is further from the root than i .
Revised: Given a jointree and its root, we say that a jointree node j is above a jointree node i if j is closer to the root than i , and that j is below i if j is further from the root than i .

Original: Proof for Theorem 2.
Revised: Proof for Theorem 2.

Original: We derive the separators for each type of edges.
Revised: We derive the separators for each type of edges.

Original: WLG, for each edge ( i, j ) , assume that j is above i .
Revised: WLG, for each edge ( i, j ) , assume that j is above i .

Original: First consider each duplicated edge ( i, j ) , we have vars t ( i, j ) =
Revised: First consider each duplicated edge ( i, j ) , we have vars t ( i, j ) =

Original: vars ( i, j ) by Algorithm 1.
Revised: vars ( i, j ) by Algorithm 1.

Original: Moreover, vars t ( j, i ) can only contain extra duplicate variables comparing to vars ( j, i ) .
Revised: Moreover, vars t ( j, i ) can only contain extra duplicate variables comparing to vars ( j, i ) .

Original: Thus, S tij = S ij .
Revised: Thus, S tij = S ij .

Original: For each duplicate edge ([ i ] , [ j ]) , we have vars t ([ i ] , [ j ])
Revised: For each duplicate edge ([ i ] , [ j ]) , we have vars t ([ i ] , [ j ])

Original: =
Revised: =

Original: [ vars ( i, j )] by Algorithm 1.
Revised: [ vars ( i, j )] by Algorithm 1.

Original: We next show that for each [ X ] ∈ vars t ([ i ] , [ j ]) , [ X ] ∈ vars t ([ j ] , [ i ]) iff X ∈ vars ( j, i ) , which then concludes S t [ i ][ j ] =
Revised: We next show that for each [ X ] ∈ vars t ([ i ] , [ j ]) , [ X ] ∈ vars t ([ j ] , [ i ]) iff X ∈ vars ( j, i ) , which then concludes S t [ i ][ j ] =

Original: [ S ij ] .
Revised: [ S ij ] .

Original: We first show the if-part.
Revised: We first show the if-part.

Original: Let u be the least common ancestor of j and [ j ] .
Revised: Let u be the least common ancestor of j and [ j ] .

Original: If X ∈ vars ( j, i ) , then X is hosted by some leaf k that appears either below u , or above u , in the base jointree.
Revised: If X ∈ vars ( j, i ) , then X is hosted by some leaf k that appears either below u , or above u , in the base jointree.

Original: Suppose k is below u , then k ’s duplicate [ k ] hosts [ X ] on the [ j ] -side in the twin jointree by Algorithm 1, which implies [ X ] ∈ vars t ([ j ] , [ i ]) .
Revised: Suppose k is below u , then k ’s duplicate [ k ] hosts [ X ] on the [ j ] -side in the twin jointree by Algorithm 1, which implies [ X ] ∈ vars t ([ j ] , [ i ]) .

Original: Suppose k is above u .
Revised: Suppose k is above u .

Original: If u is the root of the jointree, then X is a root variable and [ X ] ∈ vars t ([ j ] , [ i ]) .
Revised: If u is the root of the jointree, then X is a root variable and [ X ] ∈ vars t ([ j ] , [ i ]) .

Original: Otherwise, let p be the parent of u , then ( u, p ) is an invariant edge, and [ X ] appears on the p -side of the edge by Lemma 2.
Revised: Otherwise, let p be the parent of u , then ( u, p ) is an invariant edge, and [ X ] appears on the p -side of the edge by Lemma 2.

Original: Similar argument applies for the only-if part.
Revised: Similar argument applies for the only-if part.

Original: Suppose [ X ] ∈ vars t ([ i ] , [ j ]) , then [ X ] is hosted by some duplicate leaf [ k ] either below or above u .
Revised: Suppose [ X ] ∈ vars t ([ i ] , [ j ]) , then [ X ] is hosted by some duplicate leaf [ k ] either below or above u .

Original: If [ k ] is below u , then the duplicated node k is also below u .
Revised: If [ k ] is below u , then the duplicated node k is also below u .

Original: If [ k ] is above u , then the duplicated node k must also appear above u by Lemma 2.
Revised: If [ k ] is above u , then the duplicated node k must also appear above u by Lemma 2.

Original: For each invariant edge ( i, j ) , it follows from Lemma 2 that vars t ( i, j ) =
Revised: For each invariant edge ( i, j ) , it follows from Lemma 2 that vars t ( i, j ) =

Original: vars ( i, j ) ∪ [ vars ( i, j )] and vars t ( j, i ) = vars ( j, i ) ∪ [ vars ( j, i )] .
Revised: vars ( i, j ) ∪ [ vars ( i, j )] and vars t ( j, i ) = vars ( j, i ) ∪ [ vars ( j, i )] .

Original: Hence, S tij =
Revised: Hence, S tij =

Original: S ij ∪ [ S ij ] .
Revised: S ij ∪ [ S ij ] .

Original: Proof for Corollary 3.
Revised: Proof for Corollary 3.

Original: Let T be a jointree for G , and let T t be the twin jointree for G t obtained from Algorithm 1.
Revised: Let T be a jointree for G , and let T t be the twin jointree for G t obtained from Algorithm 1.

Original: Let i be a node in jointree T .
Revised: Let i be a node in jointree T .

Original: By Theorem 3, for all neighbors j of i , S tij ⊆
Revised: By Theorem 3, for all neighbors j of i , S tij ⊆

Original: S ij ∪ [ S ij ] .
Revised: S ij ∪ [ S ij ] .

Original: So C ti =
Revised: So C ti =

Original: (cid:83) j S tij ⊆ (cid:83) j S ij ∪ [ S ij ] =
Revised: (cid:83) j S tij ⊆ (cid:83) j S ij ∪ [ S ij ] =

Original: C i ∪ [ C i ] .
Revised: C i ∪ [ C i ] .

Original: So | C ti | ≤ | C i ∪ [ C i ] | ≤ 2 | C i | .
Revised: So | C ti | ≤ | C i ∪ [ C i ] | ≤ 2 | C i | .

Original: So w t = max i ∈ T
Revised: So w t = max i ∈ T

Original: [Equation]
Revised: [Equation]

Original: C ti
Revised: C ti

Original: [Equation]
Revised: [Equation]

Original: The number of nodes in the twin jointree is at most twice the number of nodes in the base jointree since Algorithm 1 adds at most one duplicate for each node in the base jointree.
Revised: The number of nodes in the twin jointree is at most twice the number of nodes in the base jointree since Algorithm 1 adds at most one duplicate for each node in the base jointree.

Original: Proof of Theorem
Revised: Proof of Theorem

Original: Proof for Theorem 3.
Revised: Proof for Theorem 3.

Original: From [6], a thinned jointree can be obtained by applying a sequence of thinning rules to a base jointree.
Revised: From [6], a thinned jointree can be obtained by applying a sequence of thinning rules to a base jointree.

Original: Let Q = { Q 1 , . . .
Revised: Let Q = { Q 1 , . . .

Original: , Q T } denote the T thinning rules being applied to the base jointree in order.
Revised: , Q T } denote the T thinning rules being applied to the base jointree in order.

Original: We next construct a thinning sequence Q t for the twin jointree, which leads to the thinned separators defined in the Theorem.
Revised: We next construct a thinning sequence Q t for the twin jointree, which leads to the thinned separators defined in the Theorem.

Original: We first define a parallel thinning step as simultaneously thinning a functional variable X from the base jointree and thinning { X, [ X ] } from the twin jointree.
Revised: We first define a parallel thinning step as simultaneously thinning a functional variable X from the base jointree and thinning { X, [ X ] } from the twin jointree.

Original: Consider any thinning rule Q i that thins
Revised: Consider any thinning rule Q i that thins

Original: X from a separator S ij , the parallel thinning on S t is defined as follows:
Revised: X from a separator S ij , the parallel thinning on S t is defined as follows:

Original: • Suppose ( i, j ) is a duplicated edge, then we thin X from S tij and [ X ] from S t
Revised: • Suppose ( i, j ) is a duplicated edge, then we thin X from S tij and [ X ] from S t

Original: [ i ][ j ] • Suppose ( i, j ) is an invariant edge, then we thin { X, [ X ] } from S tij
Revised: [ i ][ j ] • Suppose ( i, j ) is an invariant edge, then we thin { X, [ X ] } from S tij

Original: First note that the definition of parallel thinning ensures that the relation between S and S t specified in the theorem holds after every parallel thinning step.
Revised: First note that the definition of parallel thinning ensures that the relation between S and S t specified in the theorem holds after every parallel thinning step.

Original: It remains to show that the parallel thinnings on S t are indeed valid.
Revised: It remains to show that the parallel thinnings on S t are indeed valid.

Original: Let S , S t denote the separators for the base and twin jointree during the parallel thinnings.
Revised: Let S , S t denote the separators for the base and twin jointree during the parallel thinnings.

Original: Consider a parallel thinning step being applied to a duplicated edge, which, by definition, removes X from
Revised: Consider a parallel thinning step being applied to a duplicated edge, which, by definition, removes X from

Original: S ij , X from S tij , and [ X ] from S t [ i ][ j ] .
Revised: S ij , X from S tij , and [ X ] from S t [ i ][ j ] .

Original: Suppose the removal of X from S ij is supported by the first thinning rule, i.e. the edge ( i, j ) is on the path between two leaf nodes, call them l and r , both hosting the family of X , and every separator on that path contains X .
Revised: Suppose the removal of X from S ij is supported by the first thinning rule, i.e. the edge ( i, j ) is on the path between two leaf nodes, call them l and r , both hosting the family of X , and every separator on that path contains X .

Original: We claim that the removal of X from S tij and the removal of [ X ] from S t [ i ][ j ] are both supported by the first thinning rule.
Revised: We claim that the removal of X from S tij and the removal of [ X ] from S t [ i ][ j ] are both supported by the first thinning rule.

Original: By
Revised: By

Original: Algorithm 1, the leaf nodes { l, r } host the family of X , and the leaf nodes { [ l ] , [ r ] } host the family of [ X ] in the twin jointree.
Revised: Algorithm 1, the leaf nodes { l, r } host the family of X , and the leaf nodes { [ l ] , [ r ] } host the family of [ X ] in the twin jointree.

Original: Moreover, by the inductive assumption on separators, X appears on every separator between l and r and [ X ] appears on every separator between [ l ] and [ r ] .
Revised: Moreover, by the inductive assumption on separators, X appears on every separator between l and r and [ X ] appears on every separator between [ l ] and [ r ] .

Original: This is based on an observation that the path from l to r can be divided into three sub-paths: a sub-path consisting of only duplicated edges ( l = p 1 , . . .
Revised: This is based on an observation that the path from l to r can be divided into three sub-paths: a sub-path consisting of only duplicated edges ( l = p 1 , . . .

Original: , p s ) , a sub-path consisting of only invariant edges ( p s , . .
Revised: , p s ) , a sub-path consisting of only invariant edges ( p s , . .

Original: , p m ) , and a sub-path consisting of only duplicated edges ( p m , . .
Revised: , p m ) , and a sub-path consisting of only duplicated edges ( p m , . .

Original: , p n = r ) , where 1 < s ≤ m < n 7 .
Revised: , p n = r ) , where 1 < s ≤ m < n 7 .

Original: Given the path from l to r , we can then express the path from [ l ] to [ r ] as three sub-paths as well: a sub-path consisting of only duplicate edges ([ l ] =
Revised: Given the path from l to r , we can then express the path from [ l ] to [ r ] as three sub-paths as well: a sub-path consisting of only duplicate edges ([ l ] =

Original: [ p 1 ] , . .
Revised: [ p 1 ] , . .

Original: . , p s ) , a sub-path consisting of only invariant edges ( p s , . .
Revised: . , p s ) , a sub-path consisting of only invariant edges ( p s , . .

Original: , p m ) , and a sub-path consisting of only duplicate edges ( p m , . . .
Revised: , p m ) , and a sub-path consisting of only duplicate edges ( p m , . . .

Original: , [ p n ] =
Revised: , [ p n ] =

Original: [ r ]) .
Revised: [ r ]) .

Original: For each duplicated edge ( i, j ) on the sub-path from l to p s or on the sub-path from p m to r , X ∈ S ij iff [ X ] ∈ S
Revised: For each duplicated edge ( i, j ) on the sub-path from l to p s or on the sub-path from p m to r , X ∈ S ij iff [ X ] ∈ S

Original: [ i ][ j ] .
Revised: [ i ][ j ] .

Original: For each invariant edge ( i, j ) on the sub-path from p s to p m , X ∈ S ij iff [ X ] ∈ S ij .
Revised: For each invariant edge ( i, j ) on the sub-path from p s to p m , X ∈ S ij iff [ X ] ∈ S ij .

Original: Suppose the removal of X from S ij is supported by the second thinning rule, i.e. no other separators
Revised: Suppose the removal of X from S ij is supported by the second thinning rule, i.e. no other separators

Original: S ik contains X , or no other separators S kj contains X .
Revised: S ik contains X , or no other separators S kj contains X .

Original: Then the removal of X from S tij and the removal of [ X ] from S t
Revised: Then the removal of X from S tij and the removal of [ X ] from S t

Original: [ i ][ j ] are both supported by the second thinning rule due to the inductive assumption on separators.
Revised: [ i ][ j ] are both supported by the second thinning rule due to the inductive assumption on separators.

Original: Consider now a parallel thinning step being applied to an invariant edge which removes X from S ij and { X, [ X ] } from S tij .
Revised: Consider now a parallel thinning step being applied to an invariant edge which removes X from S ij and { X, [ X ] } from S tij .

Original: Suppose the removal of X from S ij is supported by the first thinning rule, where the edge ( i, j ) is on the path between two leaf nodes l and r both hosting the family of X and every separator on that path contains X .
Revised: Suppose the removal of X from S ij is supported by the first thinning rule, where the edge ( i, j ) is on the path between two leaf nodes l and r both hosting the family of X and every separator on that path contains X .

Original: Again, by the inductive assumption on separators, [ X ] appears in all separators on the path between [ l ] and [ r ] , which also includes the invariant edge ( i, j ) .
Revised: Again, by the inductive assumption on separators, [ X ] appears in all separators on the path between [ l ] and [ r ] , which also includes the invariant edge ( i, j ) .

Original: Hence, [ X ] can also be removed from S tij using the first thinning rule.
Revised: Hence, [ X ] can also be removed from S tij using the first thinning rule.

Original: Suppose the removal of X from S ij is supported by the second thinning rule, then we can apply the second thinning rule to remove { X, [ X ] } from S tij due to the inductive assumption on separators.
Revised: Suppose the removal of X from S ij is supported by the second thinning rule, then we can apply the second thinning rule to remove { X, [ X ] } from S tij due to the inductive assumption on separators.

Original: Proof of Theorem
Revised: Proof of Theorem

Original: We first extend the notion of twin graph sequence to N -world graph sequence , denoted as
Revised: We first extend the notion of twin graph sequence to N -world graph sequence , denoted as

Original: G N 1 , G N 2 , . .
Revised: G N 1 , G N 2 , . .

Original: , G Nn , where G N 1 is the moral graph for G N , and G Ni +1 is the result of eliminating { π ( i ) 1 , . . .
Revised: , G Nn , where G N 1 is the moral graph for G N , and G Ni +1 is the result of eliminating { π ( i ) 1 , . . .

Original: , π ( i ) N } from G Ni .
Revised: , π ( i ) N } from G Ni .

Original: For each variable X j ( j ∈ { 1 , . . . , N } ) in G Ni , let G Ni ( X j ) be the set consisting of X j and its neighbors in G Ni .
Revised: For each variable X j ( j ∈ { 1 , . . . , N } ) in G Ni , let G Ni ( X j ) be the set consisting of X j and its neighbors in G Ni .

Original: For a set of variables X , we use X j to denote { X j | X ∈ X } .
Revised: For a set of variables X , we use X j to denote { X j | X ∈ X } .

Original: Lemma 3.
Revised: Lemma 3.

Original: Consider a base network G and its N -world network G N .
Revised: Consider a base network G and its N -world network G N .

Original: Let π be an elimination order for G .
Revised: Let π be an elimination order for G .

Original: Then for each variable X j ( j ∈ { 1 , . . . , N } ) in G Ni , G Ni
Revised: Then for each variable X j ( j ∈ { 1 , . . . , N } ) in G Ni , G Ni

Original: ( X j ) ⊆ (cid:83)
Revised: ( X j ) ⊆ (cid:83)

Original: Nk =
Revised: Nk =

Original: 1 G i ( X ) k .
Revised: 1 G i ( X ) k .

Original: Proof.
Revised: Proof.

Original: We will prove this by induction on G Ni .
Revised: We will prove this by induction on G Ni .

Original: The statement holds initially for G N 1 by the definition of N -world networks.
Revised: The statement holds initially for G N 1 by the definition of N -world networks.

Original: Suppose the statement holds for G Ni − 1 , i.e. G Ni − 1 ( X j ) ⊆
Revised: Suppose the statement holds for G Ni − 1 , i.e. G Ni − 1 ( X j ) ⊆

Original: (cid:83)
Revised: (cid:83)

Original: Nk
Revised: Nk

Original: =1 G i − 1 ( X ) k for every variable X j ∈ G Ni − 1 , we need to show the statement holds for G Ni .
Revised: =1 G i − 1 ( X ) k for every variable X j ∈ G Ni − 1 , we need to show the statement holds for G Ni .

Original: Let Y =
Revised: Let Y =

Original: π ( i − 1) .
Revised: π ( i − 1) .

Original: Suppose we eliminate variables { Y k } Nk =1 from G N .
Revised: Suppose we eliminate variables { Y k } Nk =1 from G N .

Original: G Ni ( X ) is affected by the elimination of { Y k } Nk =

Revised: G Ni ( X ) is affected by the elimination of { Y k } Nk =

Original: iff X is a neighbor of { Y k } Nk =1 in G Ni .
Revised: iff X is a neighbor of { Y k } Nk =1 in G Ni .

Original: Moreover, by induction, X is a neighbor of { Y k } Nk =1 in G Ni only if X is a neighbor of Y in G i .
Revised: Moreover, by induction, X is a neighbor of { Y k } Nk =1 in G Ni only if X is a neighbor of Y in G i .

Original: When X is not a neighbor of Y , then G Ni ( X j ) =
Revised: When X is not a neighbor of Y , then G Ni ( X j ) =

Original: G Ni − 1 ( X j ) for all j = 1 , 2 , . . .
Revised: G Ni − 1 ( X j ) for all j = 1 , 2 , . . .

Original: , N and G i ( X ) =
Revised: , N and G i ( X ) =

Original: G i − 1 ( X ) , so the statement holds.
Revised: G i − 1 ( X ) , so the statement holds.

Original: When X is a neighbor of Y , for all j = 1 , 2 , . .
Revised: When X is a neighbor of Y , for all j = 1 , 2 , . .

Original: , N , we can then bound G Ni ( X j ) as follows:
Revised: , N , we can then bound G Ni ( X j ) as follows:

Original: [Equation]
Revised: [Equation]

Original: Lemma 4.
Revised: Lemma 4.

Original: Let G N be an N -world network and let j ∈ { 1 , . . .
Revised: Let G N be an N -world network and let j ∈ { 1 , . . .

Original: , N } be a positive integer.
Revised: , N } be a positive integer.

Original: Then
Revised: Then

Original: C N ( X j ) ⊆
Revised: C N ( X j ) ⊆

Original: (cid:83) N k =1 C ( X ) k .
Revised: (cid:83) N k =1 C ( X ) k .

Original: Proof.
Revised: Proof.

Original: Let X
Revised: Let X

Original: = π ( i ) .
Revised: = π ( i ) .

Original: By Lemma 3, C N ( X 1 ) =
Revised: By Lemma 3, C N ( X 1 ) =

Original: G Ni ( X 1 ) ⊆
Revised: G Ni ( X 1 ) ⊆

Original: (cid:83)
Revised: (cid:83)

Original: Nk =
Revised: Nk =

Original: 1 G i ( X ) k
Revised: 1 G i ( X ) k

Original: = (cid:83) Nk
Revised: = (cid:83) Nk

Original: =1 C ( X ) k .
Revised: =1 C ( X ) k .

Original: We next bound C N
Revised: We next bound C N

Original: ( X j ) where j ∈ { 2 , . . .
Revised: ( X j ) where j ∈ { 2 , . . .

Original: , N } by induction.
Revised: , N } by induction.

Original: For each j ∈ { 2 , . . . , N } , assume
Revised: For each j ∈ { 2 , . . . , N } , assume

Original: C N ( X h ) ⊆
Revised: C N ( X h ) ⊆

Original: (cid:83) Nk
Revised: (cid:83) Nk

Original: =1 C ( X ) k for h = 1 , 2 , . . .
Revised: =1 C ( X ) k for h = 1 , 2 , . . .

Original: , j − 1 , then
Revised: , j − 1 , then

Original: [Equation]
Revised: [Equation]

Original: ∪ j − 1 (cid:91) k
Revised: ∪ j − 1 (cid:91) k

Original: =
Revised: =

Original: C N ( X k ) (by VE definition) ⊆
Revised: C N ( X k ) (by VE definition) ⊆

Original: [Equation]
Revised: [Equation]

Original: k=
Revised: k

Original: [Equation]
Revised: [Equation]

Original: G
Revised: G

Original: [Equation]
Revised: [Equation]

Original: ( X
Revised: X

Original: [Equation]
Revised: [Equation]

Original: k ) ∪ (
Revised: k [Equation] ∪ (

Original: N (cid:91) k
Revised: N [Equation]

Original:  =
Revised: k =

Original: C ( X ) k
Revised: C ( X [Equation] k

Original: [Equation]
Revised: [Equation]

Original: (by inductive hypothesis) ⊆
Revised: (by inductive hypothesis) ⊆

Original: N (cid:91) k
Revised: N [Equation]

Original:  =
Revised: k =

Original: C ( X ) k
Revised: C ( X ) k

Original: A
Revised: A

Original: B
Revised: B

Original: C
Revised: C

Original: D
Revised: D

Original: E
Revised: E

Original: F
Revised: F

Original: [Figure]
Revised: [Figure]

Original: A
Revised: A

Original: B
Revised: B

Original: C
Revised: C

Original: D
Revised: D

Original: E
Revised: E

Original: F [ C ] [ D ] [ E ] [ F ]
Revised: F [ C ] [ D ] [ E ] [ F ]

Original: [Figure]
Revised: [Figure]

Original: [Figure]
Revised: [Figure]

Original: Proof for Corollary 4.
Revised: Proof for Corollary 4.

Original: By Lemma 4, for all X j ∈ G N , | C ( X j ) | ≤ (cid:80) Nk
Revised: By Lemma 4, for all X j ∈ G N , | C ( X j ) | ≤ (cid:80) Nk

Original: =1 | C ( X ) k | =
Revised: =1 | C ( X ) k | =

Original: N | C ( X ) | .
Revised: N | C ( X ) | .

Original: Therefore, the width w N of π N is
Revised: Therefore, the width w N of π N is

Original: [Equation]
Revised: [Equation]

Original: For causal treewidth, we can extend Algorithm 1 to construct N -world jointrees by making N −duplicates for each duplicated subtree, and construct N -world thinned jointrees by extending Theorem 3.
Revised: For causal treewidth, we can extend Algorithm 1 to construct N -world jointrees by making N −duplicates for each duplicated subtree, and construct N -world thinned jointrees by extending Theorem 3.

Original: By analogous arguments, we can show that w t = N ( w + 1) − 1 .
Revised: By analogous arguments, we can show that w t = N ( w + 1) − 1 .

Original: B Tightness of Bounds
Revised: B Tightness of Bounds

Original: As we claimed in the paper, Corollaries 1 and 3 provide tight bounds for the widths of twin elimination orders defined by Definition 2 , and twin jointrees constructed by Algorithm 1, respectively.
Revised: As we claimed in the paper, Corollaries 1 and 3 provide tight bounds for the widths of twin elimination orders defined by Definition 2 , and twin jointrees constructed by Algorithm 1, respectively.

Original: Moreover, we provide a concrete example where a base network has treewidth w and its twin network has treewidth 2 w , which suggests that our bound on treewidth in Corollary 2 may also be tight (we found these examples through exhaustive search which we were able to do on small examples only, given the allotted computational resources).
Revised: Moreover, we provide a concrete example where a base network has treewidth w and its twin network has treewidth 2 w , which suggests that our bound on treewidth in Corollary 2 may also be tight (we found these examples through exhaustive search which we were able to do on small examples only, given the allotted computational resources).

Original: For the tightness of Corollary 1 , consider the base network G shown in Figure 7a.
Revised: For the tightness of Corollary 1 , consider the base network G shown in Figure 7a.

Original: The elimination order π =
Revised: The elimination order π =

Original: ( A, B, F, D, C, E ) has width of 2 .
Revised: ( A, B, F, D, C, E ) has width of 2 .

Original: The twin network G t for G is shown in Figure 7b.
Revised: The twin network G t for G is shown in Figure 7b.

Original: By
Revised: By

Original: Definition 2 , the twin elimination order for G t is π t =
Revised: Definition 2 , the twin elimination order for G t is π t =

Original: ( A, B, F, [ F ] , D, [ D ] , C, [ C ] , E, [ E ]) which has a width of 5 .
Revised: ( A, B, F, [ F ] , D, [ D ] , C, [ C ] , E, [ E ]) which has a width of 5 .

Original: For the tightness of Corollary 3 , Figure 8a shows a base jointree for the base network G .
Revised: For the tightness of Corollary 3 , Figure 8a shows a base jointree for the base network G .

Original: This base jointree was constructed using elimination order π
Revised: This base jointree was constructed using elimination order π

Original: and it has a width of 2 .
Revised: and it has a width of 2 .

Original: Figure 8b shows a twin jointree constructed by Algorithm 1 which has a width of 5 .
Revised: Figure 8b shows a twin jointree constructed by Algorithm 1 which has a width of 5 .

Original: A
Revised: A

Original: B
Revised: B

Original: C
Revised: C

Original: D
Revised: D

Original: E
Revised: E

Original: F
Revised: F

Original: G
Revised: G

Original: H
Revised: H

Original: I
Revised: I

Original: [Figure]
Revised: [Figure]

Original: A
Revised: A

Original: B
Revised: B

Original: C
Revised: C

Original: D
Revised: D

Original: E
Revised: E

Original: F
Revised: F

Original: G
Revised: G

Original: H
Revised: H

Original: I [ E ] [ F ] [ G ] [ H ] [ I ]
Revised: I [ E ] [ F ] [ G ] [ H ] [ I ]

Original: [Figure]
Revised: [Figure]

Original: twin network, treewidth w t
Revised: twin network, treewidth w t

Original: [Figure]
Revised: [Figure]

Original: For our last example, Figure 9a shows a base network with a treewidth of 2 .
Revised: For our last example, Figure 9a shows a base network with a treewidth of 2 .

Original: Figure 9b shows the corresponding twin network which has a treewidth of 4 .
Revised: Figure 9b shows the corresponding twin network which has a treewidth of 4 .

Original: This shows that if our treewidth bound in
Revised: This shows that if our treewidth bound in

Original: Corollary 2 is not tight, then it is off by at most 1 .
Revised: Corollary 2 is not tight, then it is off by at most 1 .

Original: C More on Experiments
Revised: C More on Experiments

Original: Our experiments were run on 2.60GHz Intel Xeon E5-2670 CPU with 256 GB of memory.
Revised: Our experiments were run on 2.60GHz Intel Xeon E5-2670 CPU with 256 GB of memory.

Original: In the main paper, we plotted the jointree widths for random networks with a maximum number of parents ( p = 5 ).
Revised: In the main paper, we plotted the jointree widths for random networks with a maximum number of parents ( p = 5 ).

Original: Here we show the complete experimental results for the random networks with p = 3 , 5 , 7 generated according to the method of [10] which we discussed in the main paper.
Revised: Here we show the complete experimental results for the random networks with p = 3 , 5 , 7 generated according to the method of [10] which we discussed in the main paper.

Original: We record the widths and normalized widths for each twin jointrees.
Revised: We record the widths and normalized widths for each twin jointrees.

Original: Recall that if a jointree has clusters
Revised: Recall that if a jointree has clusters

Original: C 1 , . .
Revised: C 1 , . .

Original: , C n , then the normalized width is log 2 (cid:80) ni
Revised: , C n , then the normalized width is log 2 (cid:80) ni

Original: =1 2 | C i | .
Revised: =1 2 | C i | .

Original: Table 1 shows the complete results for rNET and Table 2 shows the complete results for rSCM.
Revised: Table 1 shows the complete results for rNET and Table 2 shows the complete results for rSCM.

Original: In addition, we report results on random networks generated by a second method proposed in [21].
Revised: In addition, we report results on random networks generated by a second method proposed in [21].

Original: Given a number of nodes n and a maximum degree 8 d for each node, the method generates a random network by repeatedly adding/removing random edges from the current DAG.
Revised: Given a number of nodes n and a maximum degree 8 d for each node, the method generates a random network by repeatedly adding/removing random edges from the current DAG.

Original: We refer to these random networks as rNET2.
Revised: We refer to these random networks as rNET2.

Original: Similarly to what we did for rNET, we then added a unique root as parent for each internal variable in rNET2.
Revised: Similarly to what we did for rNET, we then added a unique root as parent for each internal variable in rNET2.

Original: We refer to these modified networks as rSCM2.
Revised: We refer to these modified networks as rSCM2.

Original: For each combination of n ∈ { 50 , 100 , 150 , 200 } and d ∈ { 5 , 10 , 15 } , we generated 50 random base networks and reported the average widths and normalized widths for each twin jointree.
Revised: For each combination of n ∈ { 50 , 100 , 150 , 200 } and d ∈ { 5 , 10 , 15 } , we generated 50 random base networks and reported the average widths and normalized widths for each twin jointree.

Original: Table 3 shows the complete results for rNET2 and Table 4 shows the complete results for rSCM2.
Revised: Table 3 shows the complete results for rNET2 and Table 4 shows the complete results for rSCM2.

Original: The patterns in these tables resemble the ones for rNET and rSCM.
Revised: The patterns in these tables resemble the ones for rNET and rSCM.

Original: [Table]
Revised: [Table]

Original: [Table] [Table]
Revised: [Table] [Table]

Original: [Table] [Table]
Revised: [Table] [Table]

Original: [Table] [Table]
Revised: [Table] [Table]

Original: [Table] [Table]
Revised: [Table] [Table]

Original: [Table] [Table]
Revised: [Table] [Table]

Original: [Table] [Table]
Revised: [Table] [Table]

Original: [Table] [Table]
Revised: [Table] [Table]

Original: mean
Revised: mean

Original: [Table] [Table]
Revised: [Table] [Table]

Original: [Table]
Revised: [Table]

Original: 85.0 std 4.
Revised: 85.0 std 4.

Original: mean 25.
Revised: mean 25.

Original: 42.8 std 2.
Revised: 42.8 std 2.

Original: [Table] [Table]
Revised: [Table] [Table]

Original: [Table]
Revised: [Table]

Original: mean 55.
Revised: mean 55.

Original: [Table]
Revised: [Table]

Original: [Table] [Table]
Revised: [Table] [Table]

Original: [Table] [Table]
Revised: [Table] [Table]

Original: [Table] [Table]
Revised: [Table] [Table]

Original: [Table] [Table]
Revised: [Table] [Table]

Original: 84.1 std
Revised: 84.1 std

Original: [Table] [Table]
Revised: [Table] [Table]

Original: [Table] [Table]
Revised: [Table] [Table]

Original: mean 75.
Revised: mean 75.

Original: [Table] [Table]
Revised: [Table] [Table]

Original: 116.7 std 4.
Revised: 116.7 std 4.

Original: mean 31.
Revised: mean 31.

Original: 51.9 std 3.
Revised: 51.9 std 3.

Original: mean 68.
Revised: mean 68.

Original: 103.2 std 4.
Revised: 103.2 std 4.

Original: mean 95.
Revised: mean 95.

Original: [Table] [Table]
Revised: [Table] [Table]

Original: 147.9 std 4.
Revised: 147.9 std 4.

Original: [Table] [Table]
Revised: [Table] [Table]

Original: mean 40.
Revised: mean 40.

Original: [Table] [Table]
Revised: [Table] [Table]

Original: [Table] [Table]
Revised: [Table] [Table]

Original: [Table] [Table]
Revised: [Table] [Table]

Original: [Table]
Revised: [Table]

Original: mean
Revised: mean

Original: [Table] [Table]
Revised: [Table] [Table]

Original: [Table] [Table]
Revised: [Table] [Table]

Original: 125.8 std 4.
Revised: 125.8 std 4.

Original: mean 114.
Revised: mean 114.

Original: 180.1 std 4.
Revised: 180.1 std 4.

Original: [Table] [Table]
Revised: [Table] [Table]

Original: [Table]
Revised: [Table]

Original: 1 std 1.
Revised: 1 std 1.

Original: mean 32.
Revised: mean 32.

Original: 52.9 std 1.
Revised: 52.9 std 1.

Original: mean 38.
Revised: mean 38.

Original: [Table] [Table]
Revised: [Table] [Table]

Original: [Table] [Table]
Revised: [Table] [Table]

Original: [Table]
Revised: [Table]

Original: 5 std 1.
Revised: 5 std 1.

Original: [Table]
Revised: [Table]

Original: [Table] [Table]
Revised: [Table] [Table]

Original: [Table] [Table]
Revised: [Table] [Table]

Original: [Table] [Table]
Revised: [Table] [Table]

Original: mean 40.
Revised: mean 40.

Original: [Table] [Table]
Revised: [Table] [Table]

Original: [Table] [Table]
Revised: [Table] [Table]

Original: [Table] [Table]
Revised: [Table] [Table]

Original: [Table]
Revised: [Table]

Original: std 1.
Revised: std 1.

Original: [Table] [Table]
Revised: [Table] [Table]

Original: [Table] [Table]
Revised: [Table] [Table]

Original: [Table] [Table]
Revised: [Table] [Table]

Original: [Table]
Revised: [Table]

Original: mean 65.
Revised: mean 65.

Original: [Table]
Revised: [Table]

Original: 108.2 std 1.
Revised: 108.2 std 1.

Original: mean 75.
Revised: mean 75.

Original: [Table]
Revised: [Table]

Original: 127.8 std 1.
Revised: 127.8 std 1.

Original: mean 59.
Revised: mean 59.

Original: 115.0 std 2.
Revised: 115.0 std 2.

Original: mean 97.
Revised: mean 97.

Original: 162.7 std 2.
Revised: 162.7 std 2.

Original: mean 109.
Revised: mean 109.

Original: 187.7 std 2.
Revised: 187.7 std 2.

Original: mean 75.
Revised: mean 75.

Original: 144.4 std 2.
Revised: 144.4 std 2.

Original: mean 127.
Revised: mean 127.

Original: [Table]
Revised: [Table]

Original: Refer to the main paper for the details of different jointree construction methods.
Revised: Refer to the main paper for the details of different jointree construction methods.

Original: All the thinned jointrees are constructed by bounding the functional chain lengths by 10 ; see [6] for details.
Revised: All the thinned jointrees are constructed by bounding the functional chain lengths by 10 ; see [6] for details.