# Find untenable configurations

## Description

This function takes a truth table as the input, and finds various types of untenable assumptions that are usually used in function `minimize()` when excluding certain remainders or some observed configurations from the minimization process.

## Usage

    findRows(expression = "", obj, remainders = TRUE, type = 1, ...)

## Arguments

`expression` |  |  |  | String: a QCA expression written in sum of products form.
`obj` |  |  |  | A truth table (an object of class `"tt"`) or a, equivalent numerical matrix.
`remainders` |  |  |  | Logical: find remainders only or also observed configurations, when `obj` is a truth table.
`type` |  |  |  | Numeric vector, specifying the type(s) of untenable configurations
`...` |  |  |  | Additional arguments to be passed to function `truthTable()`, for the negation of the outcome.

## Details

The primary purpose is to find untenable assumptions to be excluded from the Boolean minimization process. For this reason, the input is most of the times a truth table, but for demonstration purposes it can also be a simple matrix having column names.

It started as a function to find rows that are subsets of a given SOP expression, and it developed to cover even more untenable asumptions.

Subset rows can be anything, from remainders to the observed configurations (positive output, negative output and contradictions), but the function returns only the subset configurations which do not have a positive output.

It might ocasionally find negative output configurations or contradictions, but that doesn't have any side effect because they are going to be excluded from the minimization anyways, unless contradictions are included in the minimization. The only category that really matters if they are identified or not, are the positive output configurations.

The contradictory simplifying assumptions (CSAs) are those which are used for both the presence and the absence of the outcome, while simultaneous subset relations (SSRs) when observed configurations are sufficient for both the presence and the absence of the outcome. CSAs and SSRs are incoherent conterfactuals, part of a category called Untenable Assumptions.

This function takes does what is normally done with a series of commands, in a more integrated and systematic way.

Providing a truth table is sufficient to perform all these tasks, because a truth table already contains all necessary information of how it was produced, most importantly the inclusion cut-off(s). By default, it uses the same options to produce a truth table for the negation of the outcome (if the input truth table was created for its presence, or the other way round), and minimizes both to inspect their simplifying assumptions to detect which are contradictory.

If there are such simplifying assumptions in both parsimonious solutions, it means these are contradictory, and if there are observed configurations that are sufficient for both the presence and the absence of the outcome, these are also incoherent because of the simultaneous subset relations problem.

The following types of untenable assumptions can be searched for:

`0` | all of them
`1` | subsets of a given `expression` (default)
`2` | contradictory simplifying assumptions
`3` | simultaneous subset relations

To find contradictory simplifying assumptions, a truth table for the negated outcome is constructed, using the `incl.cut` argument from the `obj` input object. If the inclusion cut-off has a single value, the same is used for the negated outcome, and if it has two values the second is used.

If very specific cutoff values are needed for the negation of the outcome, these can be provided via the `...` argument, that will be passed to function `truthTable()`.

## Value

A numeric vector of length `n`.

## Examples

    # Lipset's binary crisp version
    data(LC)
    ttLC <- truthTable(LC, "SURV", show.cases = TRUE)

    findRows("DEV*ind*STB", ttLC)

    [1] 18 26 30

    # find two thresholds to separate into two groups
    findRows(gdp, n = 2)

    [1]  8700 18000

    ## all subset rows from the truth table, not only the remainders
    findRows("DEV*ind*STB", ttLC, remainders = FALSE)

    [1] 18 22 26 30

    # Lipset's fuzzy version
    data(LF)
    ttLF <- truthTable(LF, outcome = "SURV", incl.cut = 0.8)

    findRows(obj = ttLF, type = 2) # contradictory simplifying assumptions

    [1] 10 12 14 16 17 21 25 29

    # Contradictory simplifying assumptions using different cutoff values
    # for the _negation_ of the outcome

    findRows(obj = ttLF, type = 2, incl.cut = 0.9, pri.cut = 0.7)

    [1] 10 12 16 17 18 21 25 26 28 29 30

## Author

Adrian Dusa

## See also

`truthTable`, `minimize`