Description Usage Arguments Details Value Author(s) References See Also Examples

This function performs the QCA minimization of an input truth table, or if the input is a dataset the minimization it minimizes a set of causal conditions with respect to an outcome. Three minimization methods are available: the classical Quine-McCluskey, the enhanced Quine-McCluskey and the latest Consistency Cubes algorithm that is built for performance.

All algorithms return the same, exact solutions, see Dusa (2017) and Dusa and Thiem (2015).

1 2 3 4 |

`input` |
A truth table object (preferred) or a data frame containing calibrated causal conditions and an outcome. |

`include` |
A vector of other output values to include in the minimization process. |

`exclude` |
A vector of row numbers from the truth table, or a matrix of causal combinations to exclude from the minimization process. |

`dir.exp` |
A vector of directional expectations to derive intermediate solutions. |

`pi.cons` |
Numerical fuzzy value between 0 and 1, minimal consistency threshold for a prime implicant to be declared as sufficient. |

`pi.depth` |
Integer, a maximum number of causal conditions to be used when searching for conjunctive prime implicants. |

`sol.cons` |
Numerical fuzzy value between 0 and 1, minimal consistency threshold for a model to be declared as sufficient. |

`sol.cov` |
Numerical fuzzy value between 0 and 1, minimal coverage threshold for a model to be declared as necessary. |

`sol.depth` |
Integer, a maximum number of prime implicants to be used when searching for disjunctive solutions. |

`min.pin` |
Logical, terminate the search at the depth where newly found prime implicants do not contribute to minimally solving the PI chart. |

`row.dom` |
Logical, perform row dominance in the prime implicants' chart to eliminate redundant prime implicants. |

`all.sol` |
Logical, search for all possible solutions even of not minimal. |

`details` |
Logical, print more details about the solution. |

`use.tilde` |
Logical, use tilde to signal the absence of conditions. |

`method` |
Minimization method, one of "CCubes" (default), or "QMC" the classical Quine-McCluskey, or "eQMC" the enhanced Quine-McCluskey. |

`...` |
Other arguments to be passed to function |

Most of the times, this function takes a truth table object as the ** input**
for the minimization procedure, but the same argument can refer to a data frame
containing calibrated columns.

For the later case, the function ** minimize()** originally had some additional
formal arguments which were sent to the function

`truthTable()`

`outcome`

`conditions`

`n.cut`

`incl.cut`

`show.cases`

`use.letters`

`inf.test`

All of these parameters are still possible with function ** minimize()**, but
since they are sent to the

`truthTable()`

`outcome`

`truthTable()`

`minimize()`

The argument ** include** specifies which other truth table rows are
included in the minimization process. Most often, the remainders are included but
any value accepted in the argument

`explain`

`include`

The argument ** exclude** is used to exclude truth table rows from the
minimization process, from the positive configurations and/or from the remainders.
It can be specified as a vector of truth table line numbers, or as a matrix of
causal combinations.

The argument ** dir.exp** is used to specify directional expectations, as
described by Ragin (2003). They can be specified as a single string, with values
separated by commas. For multi-value directional expectations, they are specified
together, separated by semicolons. The total length of the directional expectations
must match the number of causal conditions specified in the analysis, using a dash

`"-"`

Activating the ** details** argument has the effect of printing parameters
of fit for each prime implicant and each overall solution, the essential prime
implicants being listed in the top part of the table. It also prints the truth
table, in case the argument

`input`

The argument ** use.tilde** signals the absence of a causal condition, in
a sufficiency relation with the outcome, using a tilde sign

`"~"`

By default, the package QCA employes a different search algorithm based on Consistency Cubes (Dusa, 2017), analysing all possible combinations of causal conditions and all possible combinations of their respective levels. The structure of the input dataset (number of causal conditions, number of levels, number of unique rows in the truth table) has a direct implication on the search time, as all of those characteristics become entry parameters when calculating all possible combinations.

Consequently, two kinds of depth arguments are provided:

`pi.depth` | the maximum number of causal conditions needed to construct a prime |

implicant, the complexity level where the search can be stopped, as long as the | |

PI chart can be solved. | |

`sol.depth` | the maximum number of prime implicants needed to find a solution |

(to cover all initial positive output configurations) |

These arguments introduce a possible new way of deriving prime implicants and solutions,
that can lead to different results (i.e. even more parsimonious) compared to the classical
Quine-McCluskey. When either of them is modified from the default value of 0, the minimization
method is automatically set to ** "CCubes"** and the remainders are automatically
included in the minimization.

The search time is larger the higher these depths, or inversely the search time can be
significantly shorter if these depths are smaller. Irrespective of how large
** pi.depth** is, the algorithm will always stop at a maximum complexity level
where no new, non-redundant prime implicants are found. The argument

`sol.depth`

`all.sol`

The default method (when ** all.sol = FALSE**), is to find
the minimal number (

`k`

`k`

The argument ** min.pin** introduces an additional
parameter to control when to stop the search for prime implicants. It is based on the
observation by Dusa (2017) that
out of the entire set of non redundant prime implicants, only a subset actually contribute
to solving the chart with disjunctions of

`k`

Once the PI chart is constructed using the prime implicants found in the previous
stages, the argument ** row.dom** can be used to further eliminate
irrelevant prime implicants when solving the PI chart, applying the principle of row
dominance: if a prime implicant A covers the same (intial) positive output
configurations as another prime implicant B and in the same time covers
other configurations which B does not cover, then B is irrelevant and eliminated.

The argument ** all.sol** automatically deactivates the argument

`min.pin`

`n`

`n >= k`

The task of solving the PI chart depends on its size, with prime implicants on the
rows and the positive output configurations on the columns. Since the columns are
fixed, another possible way to reduce the solving time is to eliminate redundant rows,
by activating the argument ** row.dom**.

If minimizing a dataset instead of a truth table, unless otherwise specified the
argument ** incl.cut** is automatically set to the minimum value between

`pi.cons`

`sol.cons`

`truthTable()`

The argument ** sol.cons** introduces another possibility to change the method of
solving the PI chart. Normally, once the solutions are found among all possible combinations
of

`k`

`sol.cons`

An object of class `"qca"`

when using a single outcomes, or class `"mqca"`

when using multiple outcomes. These objects are lists having the following components:

`tt` |
The truth table object. |

`options` |
Values for the various options used in the function (including defaults). |

`negatives` |
The line number(s) of the negative configuration(s). |

`initials` |
The initial positive configuration(s). |

`PIchart` |
A list containing the PI chart(s). |

`primes` |
The prime implicant(s). |

`solution` |
A list of solution(s). |

`essential` |
A list of essential PI(s). |

`pims` |
A list of PI membership scores. |

`IC` |
The matrix containing the inclusion and coverage scores for the solution(s). |

`SA` |
A list of simplifying assumptions. |

`i.sol` |
A list of components specific to intermediate solution(s), each having a PI chart, prime implicant membership scores, (non-simplifying) easy counterfactuals and difficult counterfactuals. |

`call` |
The user's command which produced all these objects and result(s). |

Adrian Dusa

Cebotari, V.; Vink, M.P. (2013) “A Configurational Analysis of Ethnic
Protest in Europe”. *International Journal of Comparative Sociology*
vol.54, no.4, pp.298-324.

Cebotari, V.; Vink, M.P. (2015) “Replication Data for: A configurational analysis of ethnic protest in Europe”, Harvard Dataverse, V2, DOI: 10.7910/DVN/PT2IB9,

Cronqvist, L.; Berg-Schlosser, D. (2009) “Multi-Value QCA (mvQCA)”, in
Rihoux, B.; Ragin, C. (eds.) *Configurational Comparative Methods. Qualitative
Comparative Analysis (QCA) and Related Techniques*, SAGE.

Dusa, A.; Thiem, A. (2015) “Enhancing the Minimization of Boolean and
Multivalue Output Functions With eQMC” *Journal of Mathematical Sociology*
vol.39, no.2, pp.92-108,

DOI: 10.1080/0022250X.2014.897949.

Dusa, A. (2017) “Consistency Cubes: A Fast, Efficient Method for Boolean Minimization”, unpublished working paper on ResearchGate, DOI: RG.2.2.36359.19361/1

Ragin, C. (2003) *Recent Advances in Fuzzy-Set Methods and Their Application to Policy Questions*.
WP 2003-9, COMPASSS.

Ragin, C. (2009) “Qualitative Comparative Analysis Using Fuzzy-Sets (fsQCA)”,
in Rihoux, B.; Ragin, C. (eds.) *Configurational Comparative Methods.
Qualitative Comparative Analysis (QCA) and Related Techniques*, SAGE.

Ragin, C.C.; Strand, S.I. (2008) “Using Qualitative Comparative
Analysis to Study Causal Order: Comment on Caren and Panofsky (2005).”
*Sociological Methods & Research* vol.36, no.4, pp.431-441.

Rihoux, B.; De Meur, G. (2009) “Crisp Sets Qualitative Comparative Analysis
(mvQCA)”, in Rihoux, B.; Ragin, C. (eds.) *Configurational Comparative Methods.
Qualitative Comparative Analysis (QCA) and Related Techniques*, SAGE.

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 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 | ```
# -----
# Lipset binary crisp data
data(LC)
# the associated truth table
ttLC <- truthTable(LC, "SURV", sort.by = "incl, n", show.cases = TRUE)
ttLC
# conservative solution (Rihoux & De Meur 2009, p.57)
cLC <- minimize(ttLC)
cLC
# view the Venn diagram for the associated truth table
library(venn)
venn(cLC)
# add details and case names
minimize(ttLC, details = TRUE)
# negating the outcome
ttLCn <- truthTable(LC, "~SURV", sort.by = "incl, n", show.cases = TRUE)
minimize(ttLCn)
# using a tilde instead of upper/lower case names
minimize(ttLCn, use.tilde = TRUE)
# parsimonious solution, positive output
pLC <- minimize(ttLC, include = "?", details = TRUE)
pLC
# the associated simplifying assumptions
pLC$SA
# parsimonious solution, negative output
pLCn <- minimize(ttLCn, include = "?", details = TRUE)
pLCn
# -----
# Lipset multi-value crisp data (Cronqvist & Berg-Schlosser 2009, p.80)
data(LM)
# truth table
ttLM <- truthTable(LM, "SURV", conditions = "DEV, URB, LIT, IND",
sort.by = "incl", show.cases = TRUE)
# conservative solution, positive output
minimize(ttLM, details = TRUE)
# parsimonious solution, positive output
minimize(ttLM, include = "?", details = TRUE)
# negate the outcome
ttLMn <- truthTable(LM, "~SURV", conditions = "DEV, URB, LIT, IND",
sort.by = "incl", show.cases = TRUE)
# conservative solution, negative output
minimize(ttLMn, details = TRUE)
# parsimonious solution, positive output
minimize(ttLMn, include = "?", details = TRUE)
# -----
# Lipset fuzzy sets data (Ragin 2009, p.112)
data(LF)
# truth table using a very low inclusion cutoff
ttLF <- truthTable(LF, "SURV", incl.cut = 0.7,
sort.by = "incl", show.cases = TRUE)
# conservative solution
minimize(ttLF, details = TRUE)
# parsimonious solution
minimize(ttLF, include = "?", details = TRUE)
# intermediate solution using directional expectations
iLF <- minimize(ttLF, include = "?", details = TRUE,
dir.exp = "1,1,1,1,1")
iLF
# -----
# Cebotari & Vink (2013, 2015)
data(CVF)
ttCVF <- truthTable(CVF, outcome = "PROTEST", incl.cut = 0.8,
sort.by = "incl, n", show.cases = TRUE)
pCVF <- minimize(ttCVF, include = "?", details = TRUE)
pCVF
# inspect the PI chart
pCVF$PIchart
# DEMOC*ETHFRACT*poldis is dominated by DEMOC*ETHFRACT*GEOCON
# using row dominance to solve the PI chart
pCVFrd <- minimize(ttCVF, include = "?", row.dom = TRUE, details = TRUE)
# plot the prime implicants on the outcome
pims <- pCVFrd$pims
par(mfrow = c(2, 2))
for(i in 1:4) {
XYplot(pims[, i], CVF$PROTEST, cex.axis = 0.6)
}
# -----
# temporal QCA (Ragin & Strand 2008) serving the input as a dataset,
# which will automatically be passed to truthTable() as an intermediary
# step before the minimization
data(RS)
minimize(RS, outcome = "REC", details = TRUE)
``` |

QCA documentation built on July 12, 2018, 9:02 a.m.

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.