redundant {cna} | R Documentation

## Identify structurally redundant asf in a csf

### Description

`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.

### Usage

    redundant(cond, x = NULL, simplify = TRUE)

### Arguments

`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 `truthTab`, a data frame, or a list specifying the factors' value ranges if `cond` contains multi-value factors; if `x` is not `NULL`, `cond` is tested for redundancy-freeness relative to `full.tt(x)`, otherwise relative to `full.tt(cond)`.
`simplify` | Logical; if `TRUE` the result for csfs with the same number of component asfs is presented as a matrix, otherwise all results are presented as a list of logical vectors.

### Details

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 behaviour of the factors in Φ and Φ'; it is structurally redundant and, accordingly, must not be causally interpreted. For more details see the cna package vignette or Baumgartner and Falk (2018).

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.tt(cond)` in case of `x = NULL`, and by `full.tt(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 `truthTab` 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`.

### Value

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.

### Contributors

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

### References

Baumgartner, Michael and Christoph Falk. 2018. “Boolean Difference-Making: A Modern Regularity Theory of Causation”. PhilSci Archive. url: http://philsciarchive.pitt.edu/id/eprint/14876.

### See Also

`condition`, `full.tt`, `is.inus`, `csf`, `minimalizeCsf`.

### Examples

    # Binary factors.
    cond <- c("(f + a*D <-> C)*(C + A*B <-> D)*(c + a*E <-> F)", "f + a*D <-> C")
    redundant(cond)

    edu.sol <- csf(cna(d.educate))$condition
    redundant(edu.sol, d.educate)

    redundant(edu.sol, d.educate, simplify = FALSE)

    # Multi-value factors.
    tt.pban <- mvtt(d.pban)
    cna.pban <- cna(tt.pban, con = .8, cov = .9)
    csf.pban <- csf(cna.pban)
    redundant(csf.pban$condition, tt.pban)
    # If no truthTab is specified defining the factors' value ranges, the space of
    # logically possible configurations is limited to the factor values contained in
    # csf.pban, resulting in the structural redundancy of many asf.
    redundant(csf.pban$condition)

[Package cna version 2.2.0 Index]