is.inus {cna} | R Documentation

## Test disjunctive normal forms for logical redundancies

### Description

`is.inus` checks for each element of a character vector specifying Boolean disjunctive normal forms (DNFs) whether it amounts to a minimally necessary disjunction of minimally sufficient conditions relative to all logically possible configurations of the factors contained in the DNF.

### Usage

    is.inus(cond, x = NULL)

### Arguments

`cond` | Character vector specifying Boolean disjunctive normal forms (DNFs). Currently the permissible syntax is restricted to the operators `+`, `*` and `=` (in case of DNFs of type `"mv"`), with negation being expressed by lower case letters.
`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`, `is.inus` tests whether `cond` is redundancy-free relative to `full.tt(x)`, otherwise relative to `full.tt(cond)`.

### 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 (Baumgartner and Falk 2018): redundancies in necessary and sufficient conditions or structural redundancies. Redundancies may obtain relative to an analyzed set of empirical data, which, typically, are fragmented and do not feature all logically possible configurations, or they may obtain for principled logical reasons, that is, relative to all configurations that are possible according to classical Boolean logic. While the function `cna` builds redundancy-free Boolean dependency structures based on empirical data, the function `is.inus` tests necessary and sufficient conditions for logical redundancies (`redundant` performs an analogous test for structural redundancies).

`is.inus` takes a character vector `cond` specifying Boolean disjunctive normal forms (DNFs) as input and checks whether these DNFs are redundancy-free according to Boolean logic, that is, minimally necessary disjunctions of minimally sufficient conditions. A necessary disjunction is minimal if, and only if, no proper sub-disjunction of it is necessary; and a sufficient conjunction is minimal if, and only if, no proper sub-conjunction of it is sufficient (Grasshoff and May 2001). In the function's default call with `x = NULL`, this minimality test is performed relative to `full.tt(cond)`; if `x` is not `NULL`, the test is performed relative to `full.tt(x)`. As `full.tt(cond)` and `full.tt(x)` coincide in case of binary factors, the argument `x` has no effect in the crisp-set and fuzzy-set cases and, hence, does not have to be specified. In case of multi-value factors, however, the argument `x` should be specified in order to define the factors' value ranges (see details below).

A `cond` with `is.inus(cond)==FALSE` can be freed of logical redundancies by means of the `minimalize` function.

### Value

Logical vector of the same length as `cond`.

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

Grasshoff, Gerd and Michael May. 2001. “Causal Regularities.” In W Spohn, M Ledwig, M Esfeld (eds.), Current Issues in Causation, pp. 85-114. Mentis, Paderborn.

### See Also

`condition`, `full.tt`, `redundant`, `minimalize`, `cna`

### Examples

    # Crisp-set case
    # --------------
    is.inus(c("A", "A + B", "A + a*B", "A + a", "A*a"))

    is.inus("F + f*G")
    is.inus("F*G + f*H + G*H")
    is.inus("F*G + f*g + H*F + H*G")

    # Multi-value case
    # ----------------
    mvdata <- mvtt(setNames(allCombs(c(2, 3, 2)) -1, c("C", "F", "V")))
    is.inus("C=1 + F=2*V=0", mvdata)
    is.inus("C=1 + F=2*V=0", list(C=0:1, F=0:2, V=0:1))
    # When x is NULL, is.inus is applied to full.tt("C=1 + F=2*V=0"), which has only
    # one single row. That row is then interpreted to be the only possible configuration,
    # in which case C=1 + F=2*V=0 is tautologous and, hence, non-minimal.
    is.inus("C=1 + F=2*V=0")

    is.inus("C=1 + C=0*C=2", mvtt(d.pban))    # contradictory
    is.inus("C=0 + C=1 + C=2", mvtt(d.pban))  # tautologous

    # Fuzzy-set case
    # --------------
    fsdata <- fstt(d.jobsecurity)
    conds <- csf(cna(fsdata, con = 0.85, cov = 0.85))$condition
    conds <- cna:::lhs(conds)
    is.inus(conds, fsdata)
    is.inus(c("S + s", "S + s*R", "S*s"), fsdata)

[Package cna version 2.2.0 Index]