cna (version 2.2.3)

redundant: 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.

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

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 \(\Phi\) has a structural redundancy if, and only if, reducing \(\Phi\) by one or more of the asf it is composed of results in a csf \(\Phi'\) that is logically equivalent to \(\Phi\). To illustrate, suppose that \(\Phi\) is composed of three asf: asf1 * asf2 * asf3; and suppose that \(\Phi\) is logically equivalent to \(\Phi'\): asf1 * asf2. In that case, asf3 makes no difference to the behaviour of the factors in \(\Phi\) and \(\Phi'\); 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.

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

# NOT RUN {
# 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)
# }