| causal_submodel {frscore} | R Documentation |
Determine if a model is a causal submodel of another model
Description
Determine whether the causal relevance ascriptions made by
candidate solution/model x are contained in the causal
relevance ascriptions made by target model y.
Usage
causal_submodel(x, y, dat = NULL)
Arguments
x |
A string that specifies a valid |
y |
A string that specifies a valid |
dat |
A |
Details
causal_submodel() checks whether the causal relevance claims
made by the candidate model x are contained within the causal
relevance claims made by the target model y. When x and
y are multi-valued models, a further argument dat must be
provided to determine the admissible factor values for the factors featured
in x and y. This would typically be the data set that x
and y were inferred from. causal_submodel() is similar to, and
based on is.submodel() from the
cna package, with one important difference.
is.submodel() checks whether a model is a syntactic
submodel of another, and can thus be used to check whether all syntactically
explicit causal ascriptions, i.e. claims about direct causation only, of one
model are contained in another. causal_submodel() checks if all causal
relevance claims made by x, i.e. claims of either direct or indirect
causation, have a counterpart causal relevance ascription in y. In case
when all causal relevance claims of x have a suitable (see below)
counterpart in y, x is a causal submodel of y.
For x to be causal submodel of y, (1), every ascription of
direct causal relevance made by x must either have a counterpart
direct causal ascription in y, or a counterpart indirect causal
ascription in y such that x omits any factors that mediate the
relation according to y. (2), every ascription of indirect causal
relevance made by x must have a counterpart indirect causal
ascription in y. That is, every pair of factors represented as direct
cause and effect in x must either be represented as direct cause and
effect in y, or be connected by a transitive chain of direct causal
relations according to y. In the latter case, x must in addition
omit the factors that according to y mediate the causal relation in
question. Direct causal relations are those causal relations that can be
read off from the explicit syntax of an atomic solution/model ("asf"). For
example, according to A*F+B<->C, A and B are direct
causes of C on alternative paths. Furthermore, candidate model
A+B<->C is a causal submodel of the target A*F+B<->C, but
A+B*U<->C is not, since the latter makes a claim about the causal
relevance of U to C which is not made by the target. Each
direct cause is a difference-maker for its effect in some circumstances
where alternative sufficient causes of the effect are not present, and the
co-factors located on the same path are present. For example,
A*F+B<->C claims that when B is absent and F is
present, difference in the presence of A will associate with
differences in C, given some suitable configuration of factors not
explicitly represented in A*F+B<->C. When both x and y
are asfs, i.e. represent direct causal relations only, x is a causal
submodel of y if, and only if x is is a syntactic submodel of y, as the syntax of an asf is such
that every causal ascription is explicitly represented.
Judgments of direct vs. indirect causation are relative to the set of
factors included in a model. A+B<->E describes A and B as direct
causes of E, but another model that includes additional factors besides
{A,B,E} might describe these causal relations as causal chains that
include intermediate steps, as in (A+B<->C)*(C+D<->E). A+B<->E
makes no claim that would contradict the chain model; it merely says that
relative to the factor set {A,B,E}, the factors are causally ordered so
that A and B are causes of E, and there is no causal relation between
A and B. Causal order refers to the ordering of the factors by the
relation of direct causation that determines what is causally "upstream" and
"downstream" of what. The exogenous factors {A,B,D} are top-level upstream
causes in (A+B<->C)*(C+D<->E), as they are not caused by any other
factor included in the model. Endogenous factors C and E are downstream
of of {A,B} by one and two levels respectively, and E is one level
downstream of D. The chain model agrees with the direct cause model on the
causal ordering of {A,B,E} – A and B are upstream of E and not
causes of each other – but also includes an additional cause of E, C,
that is ordered between {A,B} and E along a chain of direct causal
relations. (A+B<->C)*(C+D<->E) represents a transitive causal
chain where A and B are indirectly causally relevant for
E in virtue of being causes of E's more proximate cause
C and the difference-making ability they have on E via
C. A+B<->E is a causal submodel of (A+B<->C)*(C+D<->E),
as the models agree on the causal relevance ascriptions over {A,B,E}, and
the former makes no claims whatsoever about the additional factors {C,D}
included in the latter model. Both models can be seen as descriptions of the
same causal structure, one more complete in detail than the other. An
intransitive chain is a causal chain where the influence of some
upstream causes is not transmitted to some downstream effects. For example,
(A+B<->C)*(C*a+D<->E) represents a chain where A is not
causally relevant to E despite being a cause of one of E's
direct causes (C). That is, according to this model, A is not
a difference-maker for E, and A+B<->E, which makes this claim,
is not its causal submodel.
Besides avoiding causal relevance ascriptions that are not present in the
target at all, the candidate should also attribute causal relevance
correctly in the sense of causally ordering the represented causes in a way
that is compatible with the target. Factors that appear as direct causes of
the same outcome both in the target and the candidate should be grouped into
alternative disjuncts similarly in both. Analogously, causes that appear on
different levels in a causal chain according to the target should not be
represented as same-level causes by the candidate. Say, for example, that
the target is (A+B<->C)*(C+D<->E)*(E+F<->G). Candidate models
(A+B<->G) and (A+B<->E)*(E+F<->G) are both causal submodels of
this target. By contrast, neither of (A+C<->G) and
(A+B<->C)*(C+E<->G) is a causal submodel of the target. Both of the
latter two models commit the error of representing as same-level causes
factors that the target represents as cause and effect. For example,
(A+C<->G) claims that A and C are same-level causes of
G, whereas the target says A is a cause of C. In other
words, relative to a factor set that include C, the candidate claims that
A is a direct cause of E, which is false according to the target. It is
instructive to consider the difference in implications for
difference-making: (A+C<->G) claims that differences in A
associate with differences in G when C is fixed absent, but
the target claims that this is impossible.
Finally, a causal submodel relation requires that any claims of indirect
causal relevance made by a candidate model are claims made by the target
also. Consider the target model (A+B*D<->C)*(C+D<->G) and a candidate
(A+B*D<->C)*(C<->G). Despite superficial similarity (the candidate is
a syntactic submodel of the target), the candidate is not a causal submodel
of the target. Namely, the candidate makes a claim that B is
indirectly causally relevant for G, a claim that is not made by the
target. Again, it is best to examine the specific difference-making claim in
question. The candidate model claims that differences in B make a
difference to the presence of G when D is fixed to be present.
But this is false according to the target. The target claims that G
is always present whenever D is: B is not causally relevant
for G despite being a cause of an intermediary factor C.
In its implementation, causal_submodel() relies on the fact that when
both the target and candidate are asfs, a syntactic submodel relation that
can be verified with is.submodel() is a necessary and
sufficient condition for causal submodel relation. If both the candidate and
the target are asfs, a check for syntactic submodel relation is performed,
and the result returned. When the target, or both the target and candidate
comprise more than one asf, the process is more complicated. First,
causal_submodel() checks if the component asfs of the candidate are
syntactic submodels of the target as is. If yes for all, each of the
candidate's direct causal relevance ascriptions is contained in the target,
and the function proceeds to the second phase. For those direct causal
relations that are not contained in the target, the function searches for
counterpart indirect relations in the target. Since cna models do not
represent indirect relations explicitly, these are explicated by
syntactically manipulating the target. This involves finding asfs in the
target with the same outcomes as those candidate asfs that are not syntactic
submodels of the target as is. For each such component asf of the
target, factors in the disjunction on the left hand side of the equivalence
sign ("<->") are substituted with the disjunctions, if any, that according
to the target represent their causes. The resulting expression is then
minimized to render it causally interpretable. What is left is an asf
representing some of the target's indirect causal claims as direct causal
claims. Then, the candidate asfs that are not syntactic submodels of the
target as is are tested against the manipulated target asfs for
syntactic submodel relation. This process is repeated until all the submodel
checks return TRUE, or no further substitutions are possible. In the
former case, the function proceeds to the second phase. In the latter case,
the candidate is deemed not to be a causal submodel of the target, and the
function returns FALSE.
An example is in order to illustrate the procedure so far. Say that the
target and candidate are (A+B<->C)*(C+D<->E) and A+B<->E,
respectively. Since the sole candidate asf is not a syntactic submodel of
the target, one then attempts to find indirect causal relevance ascriptions
in the target to license the direct causal claims made by the candidate asf.
By the procedure described above, one focuses on the second asf of the
target, C+D<->E, and seeks to syntactically manipulate that until it
is transformed into a syntactic supermodel of A+B<->E, or until no
transformation is possible. According to the first component asf of the
target, C is equivalent to (caused by) A+B. Hence, C in
C+D<->E can be replaced with A+B, which yields
(A+B)+D<->E, reducing simply to A+B+D<->E. Since
A+B<->E is a syntactic submodel of A+B+D<->E, we have shown
that the causal relevance claims made by the candidate are contained in the
target.
The purpose of the second phase is to check that all indirect causal claims
made by the candidate model have a counterpart in the target. This
involves doing all the substitutions of left-hand side factors by their
causes in the candidate model, to generate expressions that explicitly
represent the indirect claims of the candidate. The asfs generated by such
manipulations of the candidate model are then tested for causal
compatibility with the target, following the exact same procedure described
above. For example, say that (A+B*D<->C)*(C+D<->G) and
(A+B*D<->C)*(C<->G) are the target and the candidate, respectively.
Here, each candidate asf A+B*D<->C and C<->G has a supermodel
in one of the target asfs A+B*D<->C and C+D<->G, i.e. each
direct causal claim of the candidate has a counterpart direct causal claim
in the target, and the function proceeds to the second phase. In the second
phase, the indirect causal claims of the candidate are first made explicit.
By substituting A+B*D in place of C in the second asf of the
candidate and minimizing, one gets A+B*D<->G, which represents the
indirect causal relevance, as claimed by the candidate, of A+B*D on
G. This expression is then tested against the target as in the first
phase: the target asf with G as the outcome is manipulated to reflect
the indirect claims that the target makes about G, based on what the
target says about the indirect causes of G. After substitution and
minimization, we get A+D<->G, meaning that the target does not
make a claim of indirect causal relevance of B for G. That the
candidate's indirect causal ascriptions are not contained in the target is
shown by the fact that A+B*D<->G is not a syntactic submodel of
A+D<->G, and the function returns FALSE.
Due to the computational demands of some of the steps in the above
procedure, causal_submodel() is an approximation of a strictly
speaking valid check for causal submodel relations. Since the syntactic
manipulations and especially the minimization of the resulting expressions
is so costly, causal_submodel() relies on the
rreduce() function from the cna
package for minimization. rreduce() randomly chooses a
single reduction path to produce only one minimal form of an expression
whenever more than one exists, i.e. when the expression is ambiguous in its
causal claims. In the case of ambiguous models, the output of
causal_submodel() may depend on which reduction path(s) were chosen.
These cases are rare enough to not significantly affect the intended use of
causal_submodel() in the context of frscore. Another instance of
causal_submodel() taking a shortcut is when processing cyclic models
like (A+B<->C)*(C+D<->A). Here the problems are as much philosophical
as computational. It is clear that a cyclic candidate model cannot be a
causal submodel of a non-cyclic target. However, problems arise when testing
a non-cyclic candidate against a cyclic target: it is not clear what counts
as an incompatibility in causal ordering, given that a cyclic target model
includes factors that are causally relevant for themselves. Since many
conclusions can be argued for here but some approach must be taken to ensure
that causal_submodel() works on all valid cna models,
causal_submodel() takes the least costly option and simply checks
whether the candidate is a syntactic submodel of the target, and returns the
result.
Value
Named logical.
See Also
Examples
target <- "(A+B<->C)*(C+D<->E)"
candidate1 <- "A+B<->E"
causal_submodel(candidate1, target) # TRUE
candidate2 <- "A+C<->E"
causal_submodel(candidate2, target) # FALSE
dat <- cna::d.pban
target_mv <- "C=1 + F=2 + T=1 + C=0*F=1 <-> PB=1"
candidate_mv <- "C=1 + F=2 + T=1 <-> PB=1"
causal_submodel(candidate_mv, target_mv, dat = dat) # mv models require the 'dat' argument