Although claiming to be a novel technique, coincidence analysis is yet another form
of Boolean minimization. What it does is very similar and results in the same set of
solutions as performing separate QCA analyses where every causal condition from the
data
is considered an outcome.
This function aims to demonstrate this affirmation and show that results from package
cna can be obtained with package QCA. It is not intended to offer a
complete replacement for the function cna()
, but only to
replicate its so called “asf” - atomic solution formulas.
The three most important arguments from function cna()
have direct
correspondents in function minimize()
:
con |
corresponds to sol.cons . |
con.msc |
corresponds to pi.cons . |
Two other arguments from function cna()
have been directly
imported in this function, to complete the list of arguments that generate the same
results.
The argument ordering
splits the causal conditions in different temporal
levels, where prior arguments can act as causal conditions, but not as outcomes for the
subsequent temporal conditions. One simple way to split conditions is to use a list
object, where different components act as different temporal levels, in the order of
their index in the list: conditions from the first component act as the oldest causal
factors, while those from the and the last component are part of the most recent temporal
level.
Another, perhaps simpler way to express the same thing is to use a single character,
where factors on the same level are separated with a comma, and temporal levels are
separated by the sign <
.
A possible example is: "A, B, C < D, E < F"
.
Here, there are three temporal levels and conditions A, B and C can act as causal factors
for the conditions D, E and F, while the reverse is not possible. Given that D, E and F
happen in a subsequent temporal levels, they cannot act as causal conditions for A, B or C.
The same thing is valid with D and E, which can act as causal conditions for F, whereas
F cannot act as a causal condition for D or E, and certainly not for A, B or C.
The argument strict
controls whether causal conditions from the same temporal
level may be outcomes for each other. If activated, none of A, B and C can act as causal
conditions for the other two, and the same thing happens in the next temporal level where
neither D nor E can be causally related to each other.
Although the two functions reach the same results, they follow different methods. The input
for the minimization behind the function cna()
is a coincidence list,
while in package QCA the input for the minimization procedure is a truth table. The
difference is subtle but important, with the most important difference that package cna
is not exhaustive.
To find a set of solutions in a reasonable time, the formal choice in package cna is
to deliberately stop the search at certain (default) depths of complexity. Users are free
to experiment with these depths from the argument maxstep
, but there is no
guarantee the results will be exhaustive.
On the other hand, the function causalChain()
and generally all related
functions from package QCA are spending more time to make sure the search is
exhaustive. Depths can be set via the arguments pi.depth
and sol.depth
from the arguments in function minimize()
, but unlike package cna
these are not mandatory.
Exhaustiveness is guaranteed in package QCA precisely because it uses a truth table as
an input for the minimization procedure. The only exception is the option of finding solutions
based on their consistency, with the argument sol.cons
: for large PI charts,
time can quickly increase to infinity. If not otherwise specified in the argument
sol.depth
the function causalChain()
silently sets a complexity
level of 5 prime implicants per solution.