flamapy-sat 2.6.0.dev11__tar.gz → 2.9.0.dev0__tar.gz

{flamapy_sat-2.6.0.dev11/flamapy_sat.egg-info → flamapy_sat-2.9.0.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flamapy-sat
-Version: 2.6.0.dev11
+Version: 2.9.0.dev0
 Summary: flamapy-sat is a plugin to flamapy module
 Author-email: Flamapy <flamapy@us.es>
 License-Expression: GPL-3.0-or-later
@@ -8,8 +8,8 @@ Project-URL: Homepage, https://github.com/flamapy/pysat_metamodel
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: flamapy-fw~=2.6.0.dev11
-Requires-Dist: flamapy-fm~=2.6.0.dev11
+Requires-Dist: flamapy-fw~=2.9.0.dev0
+Requires-Dist: flamapy-fm~=2.9.0.dev0
 Requires-Dist: python-sat~=0.1.7.dev1
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
@@ -17,6 +17,9 @@ Requires-Dist: pytest-mock; extra == "dev"
 Requires-Dist: prospector; extra == "dev"
 Requires-Dist: mypy; extra == "dev"
 Requires-Dist: coverage; extra == "dev"
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: flamapy-z3~=2.9.0.dev0; extra == "test"
 Dynamic: license-file
 
 # flamapy-sat

flamapy_sat-2.9.0.dev0/flamapy/metamodels/pysat_diagnosis_metamodel/__init__.py

@@ -0,0 +1,9 @@
+from flamapy.core.manifest import PluginManifest
+from flamapy.core.models.language_level import LanguageLevel, MajorLevel, MinorLevel
+
+MANIFEST = PluginManifest(
+    name='pysat_diagnosis',
+    extension='pysat_diagnosis',
+    # Same encoder as the SAT plugin (ClauseSet), so the same language level.
+    supported_level=LanguageLevel(MajorLevel.BOOLEAN, {MinorLevel.GROUP_CARDINALITY}),
+)

flamapy_sat-2.9.0.dev0/flamapy/metamodels/pysat_diagnosis_metamodel/models/__init__.py

@@ -0,0 +1,8 @@
+from .pysat_diagnosis_model import DiagnosisModel
+from .explanation import Explanation, ExplanationItem
+
+__all__ = [
+    'DiagnosisModel',
+    'Explanation',
+    'ExplanationItem',
+]

flamapy_sat-2.9.0.dev0/flamapy/metamodels/pysat_diagnosis_metamodel/models/explanation.py

@@ -0,0 +1,35 @@
+"""Human-readable explanation values returned by the explain_* operations.
+
+Each item names a relationship or cross-tree constraint of the model (the same
+descriptions the diagnosis encoder records), and keeps the underlying assumption index so
+tools can act on the result programmatically.
+"""
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class ExplanationItem:
+    constraint_repr: str    # human-readable description of the relationship/constraint
+    index: int              # assumption id in the diagnosis model (machine-usable)
+    kind: str               # 'relationship' (tree) | 'constraint' (cross-tree)
+
+    def __str__(self) -> str:
+        return self.constraint_repr
+
+
+@dataclass(frozen=True)
+class Explanation:
+    items: tuple[ExplanationItem, ...] = ()
+
+    def descriptions(self) -> list[str]:
+        return [item.constraint_repr for item in self.items]
+
+    def __bool__(self) -> bool:
+        return bool(self.items)
+
+    def __str__(self) -> str:
+        if not self.items:
+            return 'No conflict found.'
+        return '\n'.join(
+            f'{number}. {item.constraint_repr}'
+            for number, item in enumerate(self.items, start=1))

{flamapy_sat-2.6.0.dev11 → flamapy_sat-2.9.0.dev0}/flamapy/metamodels/pysat_diagnosis_metamodel/models/pysat_diagnosis_model.py

@@ -117,7 +117,10 @@ class DiagnosisModel(PySATModel):
                              test_case: Configuration = None) -> None:
         assumption: List[int] = []
 
-        id_assumption = len(self.variables) + 1
+        # Assumption selectors start above every variable of the encoding: with Tseytin
+        # ('tseytin'/'auto') the ids after the features belong to auxiliary variables.
+        # Without auxiliary variables this is len(self.variables) + 1, as before.
+        id_assumption = self.top_variable() + 1
         id_assumption = self._prepare_assumptions_for_kb(assumption, id_assumption)
 
         start_id_configuration = len(assumption)

{flamapy_sat-2.6.0.dev11 → flamapy_sat-2.9.0.dev0}/flamapy/metamodels/pysat_diagnosis_metamodel/operations/__init__.py

@@ -8,6 +8,12 @@ from .pysat_configuration_diagnosis import (
     PySATConfigurationRepair,
     PySATFeatureExplanation,
 )
+from .pysat_explanations import (
+    PySATExplainDeadFeature,
+    PySATExplainFalseOptional,
+    PySATExplainVoidModel,
+    PySATMinimalCorrections,
+)
 
 
 __all__ = [
@@ -16,5 +22,9 @@ __all__ = [
     'PySATConfigurationRepair',
     'PySATConflict',
     'PySATDiagnosis',
+    'PySATExplainDeadFeature',
+    'PySATExplainFalseOptional',
+    'PySATExplainVoidModel',
     'PySATFeatureExplanation',
+    'PySATMinimalCorrections',
 ]

flamapy_sat-2.9.0.dev0/flamapy/metamodels/pysat_diagnosis_metamodel/operations/diagnosis/fastdiag.py

@@ -0,0 +1,2 @@
+"""Moved to flamapy.core.reasoning in 2.9; this shim is removed in 3.0."""
+from flamapy.core.reasoning.fastdiag import FastDiag  # noqa: F401

flamapy_sat-2.9.0.dev0/flamapy/metamodels/pysat_diagnosis_metamodel/operations/diagnosis/hsdag/hsdag.py

@@ -0,0 +1,2 @@
+"""Moved to flamapy.core.reasoning in 2.9; this shim is removed in 3.0."""
+from flamapy.core.reasoning.hsdag.hsdag import HSDAG  # noqa: F401

flamapy_sat-2.9.0.dev0/flamapy/metamodels/pysat_diagnosis_metamodel/operations/diagnosis/hsdag/labeler/fastdiag_labeler.py

@@ -0,0 +1,5 @@
+"""Moved to flamapy.core.reasoning in 2.9; this shim is removed in 3.0."""
+from flamapy.core.reasoning.hsdag.labeler.fastdiag_labeler import (  # noqa: F401
+    FastDiagLabeler,
+    FastDiagParameters,
+)

flamapy_sat-2.9.0.dev0/flamapy/metamodels/pysat_diagnosis_metamodel/operations/diagnosis/hsdag/labeler/labeler.py

@@ -0,0 +1,6 @@
+"""Moved to flamapy.core.reasoning in 2.9; this shim is removed in 3.0."""
+from flamapy.core.reasoning.hsdag.labeler.labeler import (  # noqa: F401
+    AbstractHSParameters,
+    IHSLabelable,
+    LabelerType,
+)

flamapy_sat-2.9.0.dev0/flamapy/metamodels/pysat_diagnosis_metamodel/operations/diagnosis/hsdag/labeler/quickxplain_labeler.py

@@ -0,0 +1,5 @@
+"""Moved to flamapy.core.reasoning in 2.9; this shim is removed in 3.0."""
+from flamapy.core.reasoning.hsdag.labeler.quickxplain_labeler import (  # noqa: F401
+    QuickXPlainLabeler,
+    QuickXPlainParameters,
+)

flamapy_sat-2.9.0.dev0/flamapy/metamodels/pysat_diagnosis_metamodel/operations/diagnosis/hsdag/node.py

@@ -0,0 +1,2 @@
+"""Moved to flamapy.core.reasoning in 2.9; this shim is removed in 3.0."""
+from flamapy.core.reasoning.hsdag.node import Node, NodeStatus  # noqa: F401

flamapy_sat-2.9.0.dev0/flamapy/metamodels/pysat_diagnosis_metamodel/operations/diagnosis/quickxplain.py

@@ -0,0 +1,2 @@
+"""Moved to flamapy.core.reasoning in 2.9; this shim is removed in 3.0."""
+from flamapy.core.reasoning.quickxplain import QuickXPlain  # noqa: F401

flamapy_sat-2.9.0.dev0/flamapy/metamodels/pysat_diagnosis_metamodel/operations/diagnosis/utils.py

@@ -0,0 +1,2 @@
+"""Moved to flamapy.core.reasoning in 2.9; this shim is removed in 3.0."""
+from flamapy.core.reasoning.utils import *  # noqa: F403

flamapy_sat-2.9.0.dev0/flamapy/metamodels/pysat_diagnosis_metamodel/operations/pysat_explanations.py

@@ -0,0 +1,257 @@
+"""User-facing explanation operations: minimal conflicts in constraint names, not indices.
+
+Both operations compute a QuickXPlain minimal conflict over the model's relationships and
+cross-tree constraints and report it through the :class:`Explanation` value type, whose
+items carry the encoder's human-readable descriptions.
+
+They rebuild a pristine diagnosis model from ``original_model`` on every execution:
+``prepare_diagnosis_task`` mutates the encoded clauses in place, so reusing the (facade-
+cached) model across calls with different inputs would corrupt the assumption ids.
+"""
+from typing import Optional, cast
+
+from flamapy.core.exceptions import FlamaException
+from flamapy.core.models import VariabilityModel
+from flamapy.core.operations import Operation
+from flamapy.core.operations.descriptor import OperationDescriptor, Input
+from flamapy.core.reasoning import QuickXPlain
+from flamapy.core.reasoning.hsdag import HSDAG
+from flamapy.core.reasoning.hsdag.labeler.fastdiag_labeler import (
+    FastDiagLabeler,
+    FastDiagParameters,
+)
+from flamapy.metamodels.fm_metamodel.models import DEFAULT_CNF_METHOD
+from flamapy.metamodels.configuration_metamodel.models import Configuration
+
+from ..models.explanation import Explanation, ExplanationItem
+from ..models.pysat_diagnosis_model import DiagnosisModel
+from ..transformations.fm_to_diag_pysat import FmToDiagPysat
+from .diagnosis.checker import ConsistencyChecker
+
+
+def _explanation_descriptions(explanation: Explanation) -> list[str]:
+    return explanation.descriptions()
+
+
+def _corrections_descriptions(explanations: list[Explanation]) -> list[list[str]]:
+    return [explanation.descriptions() for explanation in explanations]
+
+
+def _prepared_model(
+    model: DiagnosisModel, test_case: Optional[Configuration]
+) -> DiagnosisModel:
+    """A pristine diagnosis model with the task prepared.
+
+    ``prepare_diagnosis_task`` mutates the encoded clauses in place, so the (facade-cached)
+    input model is never prepared directly: we re-encode from ``original_model``.
+    """
+    original = getattr(model, 'original_model', None)
+    cnf_method = getattr(model, 'cnf_method', None) or DEFAULT_CNF_METHOD
+    working = (FmToDiagPysat(original, cnf_method=cnf_method).transform()
+               if original is not None else model)
+    working.prepare_diagnosis_task(test_case=test_case)
+    return working
+
+
+def _explanation_from(working: DiagnosisModel, indices: list[int]) -> Explanation:
+    original = getattr(working, 'original_model', None)
+    constraint_reprs = (
+        {str(ctc) for ctc in original.get_constraints()} if original is not None else set())
+    return Explanation(tuple(
+        ExplanationItem(
+            constraint_repr=working.constraint_assumption_map[index],
+            index=index,
+            kind='constraint'
+            if working.constraint_assumption_map[index] in constraint_reprs
+            else 'relationship',
+        )
+        for index in sorted(indices)))
+
+
+def _minimal_conflict(
+    model: DiagnosisModel, test_case: Optional[Configuration], solver_name: str
+) -> Explanation:
+    working = _prepared_model(model, test_case)
+    checker = ConsistencyChecker(solver_name, working.get_kb())
+    try:
+        conflict = QuickXPlain(checker).find_conflict(working.get_c(), working.get_b())
+    finally:
+        checker.delete()
+    return _explanation_from(working, conflict)
+
+
+class PySATExplainVoidModel(Operation):
+    """Why is the model void? A minimal, human-readable conflict among its constraints."""
+
+    facade = OperationDescriptor(
+        doc=(
+            'Explains why the feature model is void (encodes no valid configuration): a\n'
+            'minimal set of relationships/cross-tree constraints that is already\n'
+            'unsatisfiable (a QuickXPlain minimal conflict), in human-readable form.\n'
+            'Returns an empty list when the model is satisfiable. Requires the\n'
+            'pysat_diagnosis plugin.'
+        ),
+        returns='Union[None, List[str]]',
+        name='explain_void_model', operation='PySATExplainVoidModel',
+        default_backend='pysat_diagnosis',
+        result_adapter=_explanation_descriptions,
+    )
+
+    def __init__(self) -> None:
+        self.result = Explanation()
+        self.solver_name = 'glucose3'
+
+    def execute(self, model: VariabilityModel) -> 'PySATExplainVoidModel':
+        self.result = _minimal_conflict(cast(DiagnosisModel, model), None, self.solver_name)
+        return self
+
+    def get_result(self) -> Explanation:
+        return self.result
+
+    def get_explanation(self) -> Explanation:
+        return self.result
+
+
+class PySATExplainFalseOptional(Operation):
+    """Why is this feature false-optional? Conflict of the model plus parent without child."""
+
+    facade = OperationDescriptor(
+        doc=(
+            'Explains why a feature is false-optional (declared optional but present in\n'
+            'every valid configuration that includes its parent): a minimal set of\n'
+            'relationships/cross-tree constraints that forbids deselecting it while its\n'
+            'parent is selected (a QuickXPlain minimal conflict of the model plus\n'
+            '"parent = true, feature = false"), in human-readable form. Returns an empty\n'
+            'list when the feature is not false-optional. Requires the pysat_diagnosis\n'
+            'plugin.'
+        ),
+        returns='Union[None, List[str]]',
+        name='explain_false_optional', operation='PySATExplainFalseOptional',
+        default_backend='pysat_diagnosis',
+        inputs=(Input('feature_name', str, required=True, setter='set_feature'),),
+        result_adapter=_explanation_descriptions,
+    )
+
+    def __init__(self) -> None:
+        self.feature = ''
+        self.result = Explanation()
+        self.solver_name = 'glucose3'
+
+    def set_feature(self, feature_name: str) -> None:
+        self.feature = feature_name
+
+    def execute(self, model: VariabilityModel) -> 'PySATExplainFalseOptional':
+        diag_model = cast(DiagnosisModel, model)
+        original = getattr(diag_model, 'original_model', None)
+        feature = (original.get_feature_by_name(self.feature)
+                   if original is not None else None)
+        if feature is None:
+            raise FlamaException(f"Feature '{self.feature}' is not in the model.")
+        parent = feature.get_parent()
+        if parent is None:
+            raise FlamaException(
+                f"Feature '{self.feature}' is the root; it cannot be false-optional.")
+        test_case = Configuration({parent.name: True, self.feature: False})
+        try:
+            self.result = _minimal_conflict(diag_model, test_case, self.solver_name)
+        except KeyError as error:
+            raise FlamaException(
+                f"Feature '{self.feature}' is not in the model.") from error
+        return self
+
+    def get_result(self) -> Explanation:
+        return self.result
+
+    def get_explanation(self) -> Explanation:
+        return self.result
+
+
+class PySATMinimalCorrections(Operation):
+    """Minimal constraint sets whose removal makes a void model satisfiable (FastDiag)."""
+
+    facade = OperationDescriptor(
+        doc=(
+            'Returns the minimal corrections for a void feature model: each correction is\n'
+            'a minimal set of relationships/cross-tree constraints whose removal makes\n'
+            'the model satisfiable (FastDiag diagnoses enumerated via HSDAG), in\n'
+            'human-readable form. Returns an empty list when the model is already\n'
+            'satisfiable. ``max_corrections`` bounds how many are enumerated. Requires\n'
+            'the pysat_diagnosis plugin.'
+        ),
+        returns='Union[None, List[List[str]]]',
+        name='minimal_corrections', operation='PySATMinimalCorrections',
+        default_backend='pysat_diagnosis',
+        inputs=(Input('max_corrections', int, default=None, setter='set_max_corrections'),),
+        result_adapter=_corrections_descriptions,
+    )
+
+    def __init__(self) -> None:
+        self.max_corrections = -1  # -1 means no limit
+        self.result: list[Explanation] = []
+        self.solver_name = 'glucose3'
+
+    def set_max_corrections(self, max_corrections: int) -> None:
+        self.max_corrections = max_corrections
+
+    def execute(self, model: VariabilityModel) -> 'PySATMinimalCorrections':
+        working = _prepared_model(cast(DiagnosisModel, model), None)
+        checker = ConsistencyChecker(self.solver_name, working.get_kb())
+        try:
+            parameters = FastDiagParameters(working.get_c(), [], working.get_b())
+            hsdag = HSDAG(FastDiagLabeler(checker, parameters))
+            hsdag.max_number_diagnoses = self.max_corrections
+            hsdag.construct()
+            diagnoses = hsdag.get_diagnoses()
+        finally:
+            checker.delete()
+        self.result = [_explanation_from(working, diagnosis) for diagnosis in diagnoses]
+        return self
+
+    def get_result(self) -> list[Explanation]:
+        return self.result
+
+    def get_corrections(self) -> list[Explanation]:
+        return self.result
+
+
+class PySATExplainDeadFeature(Operation):
+    """Why is this feature dead? A minimal conflict of the model plus 'feature = true'."""
+
+    facade = OperationDescriptor(
+        doc=(
+            'Explains why a feature is dead (appears in no valid configuration): a\n'
+            'minimal set of relationships/cross-tree constraints that forbids selecting\n'
+            'it (a QuickXPlain minimal conflict of the model plus "feature = true"), in\n'
+            'human-readable form. Returns an empty list when the feature is not dead.\n'
+            'Requires the pysat_diagnosis plugin.'
+        ),
+        returns='Union[None, List[str]]',
+        name='explain_dead_feature', operation='PySATExplainDeadFeature',
+        default_backend='pysat_diagnosis',
+        inputs=(Input('feature_name', str, required=True, setter='set_feature'),),
+        result_adapter=_explanation_descriptions,
+    )
+
+    def __init__(self) -> None:
+        self.feature = ''
+        self.result = Explanation()
+        self.solver_name = 'glucose3'
+
+    def set_feature(self, feature_name: str) -> None:
+        self.feature = feature_name
+
+    def execute(self, model: VariabilityModel) -> 'PySATExplainDeadFeature':
+        diag_model = cast(DiagnosisModel, model)
+        test_case = Configuration({self.feature: True})
+        try:
+            self.result = _minimal_conflict(diag_model, test_case, self.solver_name)
+        except KeyError as error:
+            raise FlamaException(
+                f"Feature '{self.feature}' is not in the model.") from error
+        return self
+
+    def get_result(self) -> Explanation:
+        return self.result
+
+    def get_explanation(self) -> Explanation:
+        return self.result

{flamapy_sat-2.6.0.dev11 → flamapy_sat-2.9.0.dev0}/flamapy/metamodels/pysat_diagnosis_metamodel/transformations/fm_to_diag_pysat.py

@@ -1,4 +1,4 @@
-from flamapy.metamodels.fm_metamodel.models import FeatureModel, ClauseSet
+from flamapy.metamodels.fm_metamodel.models import DEFAULT_CNF_METHOD, ClauseSet, FeatureModel
 from flamapy.metamodels.pysat_metamodel.transformations.fm_to_pysat import FmToPysat
 from ..models.pysat_diagnosis_model import DiagnosisModel
 
@@ -18,7 +18,7 @@ class FmToDiagPysat(FmToPysat):
     def get_destination_extension() -> str:
         return 'pysat_diagnosis'
 
-    def __init__(self, source_model: FeatureModel, cnf_method: str = 'distributive') -> None:
+    def __init__(self, source_model: FeatureModel, cnf_method: str = DEFAULT_CNF_METHOD) -> None:
         super().__init__(source_model, cnf_method)
         self.destination_model = DiagnosisModel()
 
@@ -30,6 +30,7 @@ class FmToDiagPysat(FmToPysat):
         model.variables = dict(clause_set.variables)
         model.features = dict(clause_set.features)
         model.auxiliary_variables = set(clause_set.auxiliary_variables)
+        model.cnf_method = self.cnf_method
         model.original_model = self.source_model
         # Clause → constraint mapping (root feature / relations / cross-tree constraints).
         for description, clauses in clause_set.clause_groups:

flamapy_sat-2.9.0.dev0/flamapy/metamodels/pysat_metamodel/__init__.py

@@ -0,0 +1,46 @@
+from flamapy.core.manifest import OperationCapability, PluginManifest
+from flamapy.core.models.language_level import LanguageLevel, MajorLevel, MinorLevel
+
+# Costs are estimated milliseconds from the 2026-11-06 calibration (betty synthetic models at 1%
+# and 30% constraint density, 20-10,000 features, plus JHipster and busybox; worst case of the
+# two densities, carried forward so a curve never decreases). SAT queries scale to the largest
+# models (satisfiable 8 ms, core/dead 70 ms and false-optional 300 ms at 10,000 features), so the
+# only limits are on the operations that enumerate every configuration.
+_SAT_QUERY = ((2000, 1), (5000, 4), (10000, 8))
+_IMPLICATION_QUERIES = ((1000, 2), (2000, 4), (5000, 40), (10000, 70))
+
+MANIFEST = PluginManifest(
+    name='pysat',
+    calibration='2026-11-06',
+    extension='pysat',
+    supported_level=LanguageLevel(MajorLevel.BOOLEAN, {MinorLevel.GROUP_CARDINALITY}),
+    transformation_cost_curve=((200, 1), (1000, 4), (2000, 12), (5000, 19), (10000, 46)),
+    operations={
+        'satisfiable': OperationCapability(cost_curve=_SAT_QUERY),
+        'satisfiable_configuration': OperationCapability(cost_curve=_SAT_QUERY),
+        'core_features': OperationCapability(cost_curve=_IMPLICATION_QUERIES),
+        'dead_features': OperationCapability(cost_curve=_IMPLICATION_QUERIES),
+        'false_optional_features': OperationCapability(
+            cost_curve=((500, 2), (1000, 6), (2000, 34), (5000, 110), (10000, 300))),
+        # Atomic sets: the classes of features with the same value in every configuration,
+        # proved with grouped implication queries like the backbone.
+        'atomic_sets': OperationCapability(cost_curve=_IMPLICATION_QUERIES),
+        'minimum_configuration': OperationCapability(
+            cost_curve=((200, 2), (1000, 5), (2000, 30), (5000, 38), (10000, 110))),
+        # Pairwise sampling (the only t-wise implementation): 1.2 s at 200 features, 56 s at
+        # 500, 6.5 min at 1,000; the 2,000-feature model did not finish within 10 minutes.
+        't_wise_sampling': OperationCapability(
+            cost_curve=((50, 100), (100, 310), (200, 1200), (500, 56000), (1000, 390000),
+                        (2000, 600000))),
+        # PySATSampling returns valid configurations, but in the solver's fixed order instead of
+        # uniformly at random (BDD sampling is uniform), so it is not the sample the operation
+        # promises: approximate, and the planner only takes it on allow_approximate.
+        'sampling': OperationCapability(
+            exact=False, cost_curve=((1000, 1), (5000, 9), (10000, 15))),
+        # Counting and listing enumerate every configuration: exponential in the number of
+        # configurations rather than in the features (6 ms on the 20-feature calibration model).
+        'configurations_number': OperationCapability(max_features=30, cost=400),
+        'configurations': OperationCapability(max_features=30, cost=400),
+        'commonality': OperationCapability(max_features=30, cost=400),
+    },
+)

flamapy_sat-2.9.0.dev0/flamapy/metamodels/pysat_metamodel/models/pysat_model.py

@@ -0,0 +1,102 @@
+from itertools import chain
+from typing import Iterable, Iterator, Optional
+
+from pysat.formula import CNF
+from pysat.solvers import Solver
+
+from flamapy.core.exceptions import FlamaException
+from flamapy.core.models import VariabilityModel
+
+
+class PySATModel(VariabilityModel):
+    @staticmethod
+    def get_extension() -> str:
+        return 'pysat'
+
+    def __init__(self) -> None:
+        self._cnf = CNF()
+        self.variables: dict[str, int] = {}  # feature's name -> id
+        self.features: dict[int, str] = {}  # id -> feature's name
+        # Auxiliary (Tseytin) variable ids that are not features. They must be excluded
+        # from feature enumeration/counting; models over the features are unaffected.
+        self.auxiliary_variables: set[int] = set()
+        # The ClauseSet encoding the clauses come from ('auto', 'distributive' or 'tseytin'),
+        # or None when flamapy did not encode them (e.g. a model read from DIMACS). Operations
+        # that re-encode the feature model use it to keep the same encoding.
+        self.cnf_method: Optional[str] = None
+        self.original_model: VariabilityModel
+
+    def add_clause(self, clause: list[int]) -> None:
+        self._cnf.append(clause)
+
+    def get_variable(self, key: str) -> int:
+        if key not in self.variables:
+            raise FlamaException(f'Feature {key} not found')
+        return self.variables[key]
+
+    def get_all_clauses(self) -> CNF:
+        return self._cnf
+
+    # ---- feature projection helpers -------------------------------------------------------
+    # With cnf_method 'tseytin'/'auto' the CNF also contains auxiliary variables. Results are
+    # always reported over the features only; these helpers keep that in one place.
+
+    def is_feature(self, variable: int) -> bool:
+        """Whether a variable (or literal) is a feature, i.e. not an auxiliary variable."""
+        return abs(variable) in self.features
+
+    def is_auxiliary(self, variable: int) -> bool:
+        """Whether a variable (or literal) is an auxiliary (Tseytin) variable."""
+        return abs(variable) in self.auxiliary_variables
+
+    def feature_variables(self) -> list[int]:
+        """The ids of the feature variables, in increasing order."""
+        return sorted(self.features)
+
+    def top_variable(self) -> int:
+        """The highest variable id used by the encoding (features and auxiliary variables).
+
+        New variables (e.g. diagnosis assumption selectors) must start above it.
+        """
+        return max(chain(self.features, self.variables.values(), self.auxiliary_variables),
+                   default=0)
+
+    def selected_features(self, assignment: Iterable[int]) -> list[str]:
+        """Names of the features set to true in a solver assignment, in assignment order.
+
+        Auxiliary variables are skipped.
+        """
+        return [self.features[literal] for literal in assignment
+                if literal > 0 and literal in self.features]
+
+    def enum_feature_models(self, solver: Solver,
+                            assumptions: Iterable[int] = ()) -> Iterator[list[int]]:
+        """Enumerate the solver's models, one per distinct assignment of the features.
+
+        ``solver`` must already hold this model's clauses. Without auxiliary variables this is
+        exactly ``solver.enum_models``. With them, each model found is blocked on its feature
+        literals only, so models that differ only in auxiliary variables count once. (The
+        Tseytin gates of ClauseSet are biconditionals, which already makes the auxiliary
+        assignment unique, but the operations do not have to rely on that.) Like
+        ``enum_models``, this adds the blocking clauses to ``solver``.
+        """
+        assumptions = list(assumptions)
+        if not self.auxiliary_variables:
+            yield from solver.enum_models(assumptions=assumptions)
+            return
+        feature_variables = self.feature_variables()
+        while solver.solve(assumptions=assumptions):
+            model = solver.get_model()
+            yield model
+            true_literals = set(model)
+            solver.add_clause([-variable if variable in true_literals else variable
+                               for variable in feature_variables])
+
+    def __eq__(self, other: object) -> bool:
+        if other is None or not isinstance(other, PySATModel):
+            return False
+        return set(self.get_all_clauses().clauses) == set(other.get_all_clauses().clauses)
+
+    def __hash__(self) -> int:
+        clause_tuples = (tuple(clause) for clause in self.get_all_clauses().clauses)
+        return hash(frozenset(clause_tuples))

{flamapy_sat-2.6.0.dev11 → flamapy_sat-2.9.0.dev0}/flamapy/metamodels/pysat_metamodel/operations/__init__.py

@@ -3,6 +3,7 @@ from .pysat_satisfiable_configuration import PySATSatisfiableConfiguration
 from .pysat_configurations import PySATConfigurations
 from .pysat_configurations_number import PySATConfigurationsNumber
 from .pysat_commonality import PySATCommonality
+from .pysat_atomic_sets import PySATAtomicSets
 from .pysat_filter import PySATFilter
 from .pysat_backbone import PySATBackbone
 from .pysat_core_features import PySATCoreFeatures
@@ -12,20 +13,31 @@ from .pysat_metrics import PySATMetrics
 from .pysat_attribute_optimization import PySATAttributeOptimization
 from .pysat_minimum_configuration import PySATMinimumConfiguration
 from .pysat_twise_sampling import PySATTWiseSampling
+from .pysat_sampling import PySATSampling
+from .pysat_testing import (
+    PySATCoverage,
+    PySATCoveringArray,
+    PySATSampleReduction,
+)
 
 
 __all__ = [
+    'PySATAtomicSets',
     'PySATAttributeOptimization',
     'PySATBackbone',
     'PySATCommonality',
     'PySATConfigurations',
     'PySATConfigurationsNumber',
     'PySATCoreFeatures',
+    'PySATCoverage',
+    'PySATCoveringArray',
     'PySATDeadFeatures',
     'PySATFalseOptionalFeatures',
     'PySATFilter',
     'PySATMetrics',
     'PySATMinimumConfiguration',
+    'PySATSampleReduction',
+    'PySATSampling',
     'PySATSatisfiable',
     'PySATSatisfiableConfiguration',
     'PySATTWiseSampling',