cna (version 3.6.2)

minimalizeCsf: Eliminate structural redundancies from csf

Description

minimalizeCsf eliminates structural redundancies from complex solution formulas (csf) by recursively testing their component atomic solution formulas (asf) for redundancy and eliminating the redundant ones.

Usage

minimalizeCsf(x, ...)
# S3 method for default
minimalizeCsf(x, ct = NULL, verbose = FALSE, ..., data)
# S3 method for cna
minimalizeCsf(x, n = 20, verbose = FALSE, ...)

Value

minimalizeCsf returns an object of class "minimalizeCsf", essentially a data frame.

Arguments

x

In the default method, x is a character vector of csf. The cna method uses the strings representing the csf contained in an output object of cna (see details).

ct

Data frame, matrix or configTable with the data; optional, if all factors in x are binary, but required, if some factors are multi-value. In the default case, ct is NULL and a dataset containing all possible configurations of the variables in the condition x is used.

verbose

Logical; if TRUE additional messages on the number of csf that are found to be reducible are printed.

n

Minimal number of csf to use.

...

Further arguments passed to the methods.

data

Argument data is deprecated in minimalizeCsf(); use ct instead.

Contributors

Falk, Christoph: identification and solution of the problem of structural redundancies

Details

As of version 3.0 of the cna package, the function minimalizeCsf is automatically executed, where needed, by the default calls of the cna and csf functions. In consequence, applying the stand-alone minimalizeCsf function to an output object of cna is no longer required. The stand-alone function is kept in the package for reasons of backwards compatibility and for developing purposes. Its automatic execution can be suppressed by calling csf with minimalizeCsf = FALSE, which emulates outputs of older versions of the package.

The core criterion that Boolean dependency structures must satisfy in order to be causally interpretable is redundancy-freeness. In atomic solution formulas (asf), both sufficient and necessary conditions are completely free of redundant elements. However, when asf are conjunctively combined to complex solution formulas (csf), new redundancies may arise. A csf may contain redundant parts. To illustrate, assume that a csf is composed of three asf: asf1 * asf2 * asf3. It can happen that the conjunction asf1 * asf2 * asf3 is logically equivalent to a proper part of itself, say, to asf1 * asf2. In that case, asf3 is a so-called structural redundancy in asf1 * asf2 * asf3 and must not be causally interpreted. See the package vignette (vignette("cna")) or Baumgartner and Falk (2023) for more details.

minimalizeCsf recursively tests the asf contained in a csf for structural redundancies and eliminates the redundant ones. It takes a character vector x specifying csf as input and builds all redundancy-free csf that can be inferred from x. There are two possibilities to use minimalizeCsf. Either the csf to be tested for structural redundancies is passed to minimalizeCsf as a character vector (this is the default method), or minimalizeCsf is applied directly to the output of cna---which however, as indicated above, is superfluous as of version 3.0 of the cna package.

As a test for structural redundancies amounts to a test of logical equivalencies, it must be conducted relative to all logically possible configurations of the factors in x. That space of logical possibilities is generated by full.ct(x) if the ct argument takes its default value. If all factors in x are binary, providing a non-default ct value is optional and without influence on the output of minimalizeCsf. If some factors in x are multi-value, minimalizeCsf needs to be given the range of these values by means of the ct argument. ct can be a data frame or configTable listing all possible value configurations.

References

Baumgartner, Michael and Christoph Falk. 2023. “Boolean Difference-Making: A Modern Regularity Theory of Causation”. The British Journal for the Philosophy of Science, 74(1), 171-197.

See Also

csf, cna, redundant, full.ct.

Examples

# The default method.
minimalizeCsf("(f + a*D <-> C)*(C + A*B <-> D)*(c + a*E <-> F)")
minimalizeCsf("(f + a*D <-> C)*(C + A*B <-> D)*(c + a*E <-> F)", 
              verbose = TRUE) # Same result, but with some messages.
              
# The cna method.
dat1 <- selectCases("(C + A*B <-> D)*(c + a*E <-> F)")
(ana1 <- cna(dat1, details = c("r"), inus.only = FALSE))
csf(ana1, minimalizeCsf = FALSE)
# The attribute "redundant" taking the value TRUE in ana1 shows that this csf contains 
# at least one redundant element. Applying minimalizeCsf() identifies and removes
# the redundant element.
minimalizeCsf(ana1)