Description Usage Arguments Details Value Contributors References See Also Examples

`redundant`

takes a character vector `cond`

containing complex solution formulas (csf) as input and tests for each element of `cond`

whether the atomic solution formulas (asf) it consists of are structurally redundant.

1 |

`cond` |
Character vector specifying complex solution formulas (csf); only strings of type csf are allowed, meaning conjunctions of one or more asf. |

`x` |
An optional argument providing a |

`simplify` |
Logical; if |

According to the regularity theory of causation underlying CNA, a Boolean dependency structure is causally interpretable only if it does not contain any redundant elements. Boolean dependency structures may feature various types of redundancies, one of which are so-called *structural redundancies*. A csf *Φ* has a structural redundancy if, and only if, reducing *Φ* by one or more of the asf it is composed of results in a csf *Φ'* that is logically equivalent to *Φ*. To illustrate, suppose that *Φ* is composed of three asf: asf1 * asf2 * asf3; and suppose that *Φ* is logically equivalent to *Φ'*: asf1 * asf2. In that case, asf3 makes no difference to the behavior of the factors in *Φ* and *Φ'*; it is structurally redundant and, accordingly, must not be causally interpreted. For more details see the package vignette (`vignette("cna")`

) or Baumgartner and Falk (2019).

The function `redundant`

takes a character vector `cond`

composed of csf as input an tests for each element of `cond`

whether it is structurally redundant or not. 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 `cond`

. That space of logical possibilities is generated by `full.ct(cond)`

in case of `x = NULL`

, and by `full.ct(x)`

otherwise. If all factors in `cond`

are binary, `x`

is optional and without influence on the output of `redundant`

. If some factors in `cond`

are multi-value, `redundant`

needs to be given the range of these values. `x`

can be a data frame or `configTable`

listing all possible value configurations or a list of the possible values for each factor in `cond`

.

If `redundant`

returns `TRUE`

for a csf, that csf must not be causally interpreted but further processed by `minimalizeCsf`

. As of version 3.0 of the cna package, standard calls of the `cna`

and `csf`

functions automatically eliminate all structurally redundant asf.

A list of logical vectors or a logical matrix.

If all `csf`

in `cond`

have the same number of `asf`

and `simplify = TRUE`

, the result is a logical matrix with `length(cond)`

rows and the number of columns corresponds to the number of `asf`

in each `csf`

. In all other cases, a list of logical vectors of the same length as `cond`

is returned.

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

Baumgartner, Michael and Christoph Falk. 2019. “Boolean Difference-Making: A Modern Regularity Theory of Causation”. *The British Journal for the Philosophy of Science*.

doi:10.1093/bjps/axz047.

`condition`

, `full.ct`

, `is.inus`

, `csf`

, `minimalizeCsf`

.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 | ```
# Binary factors.
cond1 <- c("(f + a*D <-> C)*(C + A*B <-> D)*(c + a*E <-> F)", "f + a*D <-> C")
redundant(cond1)
edu.sol <- csf(cna(d.educate), inus.only = FALSE)$condition
redundant(edu.sol, d.educate)
redundant(edu.sol, d.educate, simplify = FALSE)
# Default application of csf() with automatic elimination of structural redundancies.
ct.pban <- configTable(d.pban)
cna.pban <- cna(ct.pban, con = .75, cov = .75)
csf.pban <- csf(cna.pban)
redundant(csf.pban$condition, ct.pban) # no solutions with structural redundancies are returned
# Non-default application of csf() without automatic elimination of structural redundancies.
csf.pban <- csf(cna.pban, inus.only = FALSE)
redundant(csf.pban$condition, ct.pban) # various solutions with structural redundancies are
# returned
# If no x is specified defining the factors' value ranges, the space of
# logically possible configurations is limited to the factor values contained in
# cond, resulting in structural redundancies that disappear as soon as x is specified.
cond2 <- "(C=0*F=0 + G=1<-> T=2)*(T=2 + G=2 <-> P=1)"
redundant(cond2)
redundant(cond2, list(C=0:2, F=0:2, G=0:3, T=0:2, P=0:2))
``` |

Embedding an R snippet on your website

Add the following code to your website.

For more information on customizing the embed code, read Embedding Snippets.