Minimization API

Pluggable minimization backends.

class qca.minimizers.Implicant(pattern, covered, is_prime=True)[source]

One Quine-McCluskey implicant.

Parameters:

  • pattern (tuple[Any, ...])

  • covered (frozenset[int])

  • is_prime (bool)

complexity()[source]

Return the number of non-wildcard conditions.

Return type:

int

covers(minterm_idx)[source]

Return whether this implicant covers a minterm index.

Parameters:

minterm_idx (int)

Return type:

bool

subsumes(other)[source]

Return whether this implicant logically subsumes another.

Parameters:

other (Implicant)

Return type:

bool

label(condition_names)[source]

Return a human-readable label.

Parameters:

condition_names (list[str])

Return type:

str

class qca.minimizers.QMSolution(complex_solution=<factory>, parsimonious_solution=<factory>, intermediate_solution=<factory>, prime_implicants_complex=<factory>, prime_implicants_parsimonious=<factory>, prime_implicants_intermediate=<factory>, coverage_table=<factory>, backend='qmc', condition_names=<factory>, n_positive=0, n_remainder=0, n_contradiction=0)[source]

Complete Quine-McCluskey solution bundle.

Parameters:

  • complex_solution (list[Implicant])

  • parsimonious_solution (list[Implicant])

  • intermediate_solution (list[Implicant])

  • prime_implicants_complex (list[Implicant])

  • prime_implicants_parsimonious (list[Implicant])

  • prime_implicants_intermediate (list[Implicant])

  • coverage_table (DataFrame)

  • backend (str)

  • condition_names (list[str])

  • n_positive (int)

  • n_remainder (int)

  • n_contradiction (int)

summary()[source]

Return a summary DataFrame.

Return type:

DataFrame

complexity_reduction()[source]

Return each solution’s complexity reduction from the complex solution.

Return type:

dict[str, int]

class qca.minimizers.MinimizerBackend(name, family, description, exact)[source]

Description of one minimization backend.

Parameters:

  • name (str)

  • family (str)

  • description (str)

  • exact (bool)

qca.minimizers.available_minimizers()[source]

Return canonical backend names accepted by fit(minimizer=...).

Return type:

tuple[str, …]

qca.minimizers.quine_mccluskey(minterms, all_patterns, is_multivalue, dont_care_indices=None)[source]

Quine mccluskey.

Parameters:

  • minterms (list[int])

  • all_patterns (list[tuple[Any, ...]])

  • is_multivalue (list[bool])

  • dont_care_indices (list[int] | None)

Return type:

list[Implicant]

qca.minimizers.greedy_set_cover(candidates, target_minterms)[source]

Return a deterministic greedy set cover over implicant candidates.

Parameters:

  • candidates (list[Implicant])

  • target_minterms (list[int])

Return type:

list[Implicant]

qca.minimizers.exact_set_cover(candidates, target_minterms)[source]

Return an exact minimum set cover using branch-and-bound search.

The optimization criterion is lexicographic:

  1. fewest implicants;

  2. lowest total logical complexity;

  3. deterministic original candidate order.

Parameters:

  • candidates (list[Implicant])

  • target_minterms (list[int])

Return type:

list[Implicant]

qca.minimizers.select_set_cover(candidates, target_minterms, method='exact')[source]

Select implicants with a set-cover backend.

Parameters:

  • candidates (list[Implicant])

  • target_minterms (list[int])

  • method (Literal['greedy', 'exact'])

Return type:

list[Implicant]

class qca.minimizers.QCAMinimizer(condition_names, is_multivalue, condition_domains, backend_name='qmc')[source]

Logical minimization engine for QCA truth tables.

Parameters:

  • condition_names (list[str])

  • is_multivalue (IsMultiValueMap)

  • condition_domains (ConditionDomains)

  • backend_name (str)

property n_minterms: int

N minterms.

minimize(truth_table_rows, outcome_threshold=0.75, consistency_threshold=None, pri_cut=0.0, frequency_cutoff=1, directional_expectations=None, include_remainders_in_parsimonious=True)[source]

Derive complex, parsimonious, and intermediate solutions.

Parameters:

  • truth_table_rows (list[TruthTableRowProtocol])

  • outcome_threshold (float)

  • consistency_threshold (float | None)

  • pri_cut (float)

  • frequency_cutoff (int)

  • directional_expectations (dict[str, Any] | None)

  • include_remainders_in_parsimonious (bool)

Return type:

QMSolution

classify_rows(truth_table_rows, outcome_threshold=0.75, consistency_threshold=None, pri_cut=0.0, frequency_cutoff=1)[source]

Classify rows.

Parameters:

  • truth_table_rows (list[TruthTableRowProtocol])

  • outcome_threshold (float)

  • consistency_threshold (float | None)

  • pri_cut (float)

  • frequency_cutoff (int)

Return type:

dict[str, list[int]]

remainder_summary(truth_table_rows, outcome_threshold=0.75, consistency_threshold=None, pri_cut=0.0, frequency_cutoff=1, directional_expectations=None)[source]

Return diagnostic remainder classification results.

Parameters:

  • truth_table_rows (list[TruthTableRowProtocol])

  • outcome_threshold (float)

  • consistency_threshold (float | None)

  • pri_cut (float)

  • frequency_cutoff (int)

  • directional_expectations (dict[str, Any] | None)

Return type:

DataFrame

class qca.minimizers.SetCoverMinimizer(condition_names, is_multivalue, condition_domains, cover_method='exact', backend_name=None)[source]

QCA minimizer using set-covering for implicant selection.

Parameters:

  • condition_names (list[str])

  • is_multivalue (IsMultiValueMap)

  • condition_domains (ConditionDomains)

  • cover_method (SetCoverMethod)

  • backend_name (str | None)

qca.minimizers.minimize_truth_table(qca, outcome_threshold=0.75, consistency_threshold=None, pri_cut=0.0, frequency_cutoff=1, directional_expectations=None, include_remainders_in_parsimonious=True, backend='qmc')[source]

Run QCA minimization directly from a model instance.

Parameters:

  • qca (QCAEngineBase)

  • outcome_threshold (float)

  • consistency_threshold (float | None)

  • pri_cut (float)

  • frequency_cutoff (int)

  • directional_expectations (DirectionalExpectations | None)

  • include_remainders_in_parsimonious (bool)

  • backend (str)

Return type:

QMSolution

class qca.minimizers.MinimizerBenchmarkResult(records)[source]

Tabular benchmark result for one or more minimization backends.

Parameters:

records (DataFrame)

summary()[source]

Return per-backend aggregate timing and solution statistics.

Return type:

DataFrame

qca.minimizers.benchmark_minimizers(qca_model, minimizers=None, repeats=1, suppress_warnings=True, **fit_kwargs)[source]

Benchmark several minimizer backends against one QCA model.

Parameters:

  • qca_model (Any) – Any PyQCA engine exposing fit(minimizer=...).

  • minimizers (Sequence[str] | None) – Backend names or aliases. Defaults to all available backends.

  • repeats (int) – Number of runs per backend.

  • suppress_warnings (bool) – Suppress expected minimization warnings during timing runs.

  • **fit_kwargs (Any) – Forwarded to qca_model.fit().

Return type:

MinimizerBenchmarkResult