flamapy-sat 2.5.0.dev0__tar.gz → 2.6.0__tar.gz

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

@@ -1,15 +1,15 @@
 Metadata-Version: 2.4
 Name: flamapy-sat
-Version: 2.5.0.dev0
+Version: 2.6.0
 Summary: flamapy-sat is a plugin to flamapy module
 Author-email: Flamapy <flamapy@us.es>
 License-Expression: GPL-3.0-or-later
 Project-URL: Homepage, https://github.com/flamapy/pysat_metamodel
-Requires-Python: >=3.9
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: flamapy-fw~=2.5.0.dev0
-Requires-Dist: flamapy-fm~=2.5.0.dev0
+Requires-Dist: flamapy-fw~=2.6.0
+Requires-Dist: flamapy-fm~=2.6.0
 Requires-Dist: python-sat~=0.1.7.dev1
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
@@ -19,19 +19,18 @@ Requires-Dist: mypy; extra == "dev"
 Requires-Dist: coverage; extra == "dev"
 Dynamic: license-file
 
-# pysat_metamodel
+# flamapy-sat
 
-This repository will host the pysat metamodel and its operation implementation
+SAT-based analysis for [flamapy](https://flamapy.org) feature models (PySAT
+backend, giving access to more than ten SAT solvers). Also ships the diagnosis
+metamodel (conflict detection and diagnosis).
 
+**Documentation:**
+- SAT plugin: https://docs.flamapy.org/framework/plugins/sat_plugin
+- Diagnosis plugin: https://docs.flamapy.org/framework/plugins/diagnosis_plugin
 
-## Install for development
+## Installation
 
-``` bash
-pip install -e .
-```
-
-## Make sure that you have installed python-dev 
-
-``` bash
-sudo apt install python-dev #python3-dev in Ubuntu derivatives
+```bash
+pip install flamapy-sat
 ```

flamapy_sat-2.6.0/README.md

@@ -0,0 +1,15 @@
+# flamapy-sat
+
+SAT-based analysis for [flamapy](https://flamapy.org) feature models (PySAT
+backend, giving access to more than ten SAT solvers). Also ships the diagnosis
+metamodel (conflict detection and diagnosis).
+
+**Documentation:**
+- SAT plugin: https://docs.flamapy.org/framework/plugins/sat_plugin
+- Diagnosis plugin: https://docs.flamapy.org/framework/plugins/diagnosis_plugin
+
+## Installation
+
+```bash
+pip install flamapy-sat
+```

flamapy_sat-2.6.0/flamapy/metamodels/pysat_diagnosis_metamodel/operations/__init__.py

@@ -0,0 +1,20 @@
+# pylint: disable=cyclic-import
+
+from .pysat_abstract_identifier import PySATAbstractIdentifier
+from .pysat_conflict import PySATConflict
+from .pysat_diagnosis import PySATDiagnosis
+from .pysat_configuration_diagnosis import (
+    PySATConfigurationConflict,
+    PySATConfigurationRepair,
+    PySATFeatureExplanation,
+)
+
+
+__all__ = [
+    'PySATAbstractIdentifier',
+    'PySATConfigurationConflict',
+    'PySATConfigurationRepair',
+    'PySATConflict',
+    'PySATDiagnosis',
+    'PySATFeatureExplanation',
+]

flamapy_sat-2.6.0/flamapy/metamodels/pysat_diagnosis_metamodel/operations/pysat_configuration_diagnosis.py

@@ -0,0 +1,205 @@
+"""Diagnosis-powered operations for interactive configuration.
+
+These turn the low-level QuickXPlain/FastDiag machinery into configuration-level answers
+that a configurator can surface directly:
+
+- ``PySATConfigurationConflict``: a minimal set of user decisions that together with the
+  model are inconsistent ("these choices clash").
+- ``PySATConfigurationRepair``: a minimal set of decisions to retract to restore
+  consistency ("undo one of these to continue").
+- ``PySATFeatureExplanation``: for a feature that is forced by the current decisions, the
+  minimal set of decisions responsible ("this feature is on because of these choices").
+
+Each consumes a ``PySATModel`` (the feature-model CNF) and a partial ``Configuration``.
+Decisions are returned as ``(feature_name, selected)`` pairs.
+"""
+from typing import Optional, cast
+
+from flamapy.core.models import VariabilityModel
+from flamapy.core.operations import Operation
+from flamapy.core.operations.descriptor import OperationDescriptor, Input
+from flamapy.metamodels.configuration_metamodel.models.configuration import Configuration
+from flamapy.metamodels.pysat_metamodel.models.pysat_model import PySATModel
+
+from .diagnosis.checker import ConsistencyChecker
+from .diagnosis.quickxplain import QuickXPlain
+from .diagnosis.fastdiag import FastDiag
+
+
+Decision = tuple[str, bool]
+
+
+def _clauses_and_decisions(
+    model: PySATModel, configuration: Configuration
+) -> tuple[list[list[int]], list[tuple[int, str, bool]]]:
+    clauses = [list(clause) for clause in model.get_all_clauses().clauses]
+    decisions: list[tuple[int, str, bool]] = []
+    for name, value in configuration.elements.items():
+        variable = model.variables.get(name)
+        if variable is None:
+            continue
+        selected = bool(value)
+        decisions.append((variable if selected else -variable, name, selected))
+    return clauses, decisions
+
+
+def _decisions_from_literals(
+    literals: list[int], decisions: list[tuple[int, str, bool]]
+) -> list[Decision]:
+    by_literal = {literal: (name, value) for literal, name, value in decisions}
+    return [by_literal[literal] for literal in literals if literal in by_literal]
+
+
+class PySATConfigurationConflict(Operation):
+    """Minimal subset of the user's decisions that is inconsistent with the model."""
+
+    facade = OperationDescriptor(
+        doc=(
+            'Returns a minimal subset of the configuration decisions that is inconsistent with\n'
+            'the feature model — the conflict explaining why the (partial) configuration cannot\n'
+            'be completed. Requires the pysat_diagnosis plugin.'
+        ),
+        returns='Union[None, List[Any]]',
+        name='configuration_conflict', operation='PySATConfigurationConflict',
+        default_backend='pysat_diagnosis',
+        inputs=(Input('configuration_path', str, required=True, kind='configuration',
+                      setter='set_configuration'),),
+    )
+
+    def __init__(self) -> None:
+        self._configuration: Optional[Configuration] = None
+        self._result: list[Decision] = []
+
+    def set_configuration(self, configuration: Configuration) -> None:
+        self._configuration = configuration
+
+    def get_conflict(self) -> list[Decision]:
+        return self._result
+
+    def get_result(self) -> list[Decision]:
+        return self._result
+
+    def execute(self, model: VariabilityModel) -> 'PySATConfigurationConflict':
+        sat_model = cast(PySATModel, model)
+        clauses, decisions = _clauses_and_decisions(sat_model, self._configuration)
+        checker = ConsistencyChecker('glucose3', clauses)
+        conflict = QuickXPlain(checker).find_conflict([lit for lit, _, _ in decisions], [])
+        checker.delete()
+        self._result = _decisions_from_literals(conflict, decisions)
+        return self
+
+
+class PySATConfigurationRepair(Operation):
+    """Minimal subset of the user's decisions to retract to restore consistency."""
+
+    facade = OperationDescriptor(
+        doc=(
+            'Returns a minimal subset of the configuration decisions to retract in order to\n'
+            'restore consistency with the feature model — how to repair an over-constrained\n'
+            'configuration. Requires the pysat_diagnosis plugin.'
+        ),
+        returns='Union[None, List[Any]]',
+        name='configuration_repair', operation='PySATConfigurationRepair',
+        default_backend='pysat_diagnosis',
+        inputs=(Input('configuration_path', str, required=True, kind='configuration',
+                      setter='set_configuration'),),
+    )
+
+    def __init__(self) -> None:
+        self._configuration: Optional[Configuration] = None
+        self._result: list[Decision] = []
+
+    def set_configuration(self, configuration: Configuration) -> None:
+        self._configuration = configuration
+
+    def get_repair(self) -> list[Decision]:
+        return self._result
+
+    def get_result(self) -> list[Decision]:
+        return self._result
+
+    def execute(self, model: VariabilityModel) -> 'PySATConfigurationRepair':
+        sat_model = cast(PySATModel, model)
+        clauses, decisions = _clauses_and_decisions(sat_model, self._configuration)
+        checker = ConsistencyChecker('glucose3', clauses)
+        diagnosis = FastDiag(checker).find_diagnosis([lit for lit, _, _ in decisions], [])
+        checker.delete()
+        self._result = _decisions_from_literals(diagnosis, decisions)
+        return self
+
+
+class PySATFeatureExplanation(Operation):
+    """Explain why a feature is forced by the current decisions.
+
+    ``get_forced_value()`` is the value the feature is forced to (or ``None`` if it is not
+    forced), and ``get_result()`` is the minimal set of decisions responsible.
+    """
+
+    facade = OperationDescriptor(
+        doc=(
+            'Explains why a feature is forced (selected or deselected) by the current\n'
+            'configuration: returns the minimal set of decisions responsible. ``feature_name``\n'
+            'is the feature to explain. Requires the pysat_diagnosis plugin.'
+        ),
+        returns='Union[None, List[Any]]',
+        name='feature_explanation', operation='PySATFeatureExplanation',
+        default_backend='pysat_diagnosis',
+        inputs=(
+            Input('configuration_path', str, required=True, kind='configuration',
+                  setter='set_configuration'),
+            Input('feature_name', str, required=True, setter='set_feature'),
+        ),
+    )
+
+    def __init__(self) -> None:
+        self._configuration: Optional[Configuration] = None
+        self._feature: Optional[str] = None
+        self._forced_value: Optional[bool] = None
+        self._result: list[Decision] = []
+
+    def set_configuration(self, configuration: Configuration) -> None:
+        self._configuration = configuration
+
+    def set_feature(self, feature_name: str) -> None:
+        self._feature = feature_name
+
+    def get_forced_value(self) -> Optional[bool]:
+        return self._forced_value
+
+    def get_explanation(self) -> list[Decision]:
+        return self._result
+
+    def get_result(self) -> list[Decision]:
+        return self._result
+
+    def execute(self, model: VariabilityModel) -> 'PySATFeatureExplanation':
+        sat_model = cast(PySATModel, model)
+        self._forced_value = None
+        self._result = []
+        if self._feature is None:
+            return self
+        clauses, decisions = _clauses_and_decisions(sat_model, self._configuration)
+        variable = sat_model.variables.get(self._feature)
+        if variable is None:
+            return self
+
+        literals = [lit for lit, _, _ in decisions]
+        checker = ConsistencyChecker('glucose3', clauses)
+        can_be_true = checker.is_consistent([*literals, variable], [])
+        can_be_false = checker.is_consistent([*literals, -variable], [])
+        if can_be_true and not can_be_false:
+            self._forced_value = True
+            forbidden = -variable
+        elif can_be_false and not can_be_true:
+            self._forced_value = False
+            forbidden = variable
+        else:
+            checker.delete()  # not forced (or already contradictory) -> no explanation
+            return self
+
+        # The minimal decisions that, with the model, entail the forced value are those
+        # inconsistent with the model plus the opposite assignment.
+        explanation = QuickXPlain(checker).find_conflict(literals, [forbidden])
+        checker.delete()
+        self._result = _decisions_from_literals(explanation, decisions)
+        return self

{flamapy_sat-2.5.0.dev0 → flamapy_sat-2.6.0}/flamapy/metamodels/pysat_diagnosis_metamodel/operations/pysat_conflict.py

@@ -1,6 +1,7 @@
 from typing import Tuple
 
 from flamapy.metamodels.pysat_diagnosis_metamodel.models import DiagnosisModel
+from flamapy.core.operations.descriptor import OperationDescriptor, Input
 from . import PySATAbstractIdentifier
 from .diagnosis.checker import ConsistencyChecker
 from .diagnosis.hsdag.hsdag import HSDAG
@@ -18,6 +19,28 @@ class PySATConflict(PySATAbstractIdentifier):
     - max_depth - specify the maximum depth of the HSDAG to be computed
     """
 
+    facade = OperationDescriptor(
+        doc=(
+            'Returns a list of conflict sets: minimal subsets of the model constraints that\n'
+            'are inconsistent with the given configuration. Requires the pysat_diagnosis\n'
+            'plugin.\n'
+            '\n'
+            '``configuration_path`` accepts a configuration file path, a ``{feature:\n'
+            'value}`` mapping, or a Configuration object. ``test_case_path`` is optional\n'
+            'and, when given, looks for conflicts against that expected outcome instead;\n'
+            'same input types.'
+        ),
+        returns='Union[None, List[str]]',
+        name='conflict', operation='PySATConflict', default_backend='pysat_diagnosis',
+        inputs=(
+            Input('configuration_path', str, required=True, kind='configuration',
+                  setter='set_configuration'),
+            Input('test_case_path', str, default=None, kind='configuration',
+                  setter='set_test_case'),
+            Input('max_conflicts', int, default=None, setter='set_max_conflicts'),
+        ),
+    )
+
     def __init__(self) -> None:
         super().__init__()
         self.max_conflicts = -1  # -1 means no limit

{flamapy_sat-2.5.0.dev0 → flamapy_sat-2.6.0}/flamapy/metamodels/pysat_diagnosis_metamodel/operations/pysat_diagnosis.py

@@ -1,6 +1,7 @@
 from typing import Tuple
 
 from flamapy.metamodels.pysat_diagnosis_metamodel.models import DiagnosisModel
+from flamapy.core.operations.descriptor import OperationDescriptor, Input
 from . import PySATAbstractIdentifier
 from .diagnosis.checker import ConsistencyChecker
 from .diagnosis.hsdag.hsdag import HSDAG
@@ -18,6 +19,29 @@ class PySATDiagnosis(PySATAbstractIdentifier):
     - max_depth - specify the maximum depth of the HSDAG to be computed
     """
 
+    facade = OperationDescriptor(
+        doc=(
+            'Returns a list of diagnoses explaining why a configuration is not valid\n'
+            'against the feature model: each diagnosis is a minimal set of constraints\n'
+            'whose removal would resolve the inconsistency. Requires the pysat_diagnosis\n'
+            'plugin.\n'
+            '\n'
+            '``configuration_path`` accepts a configuration file path, a ``{feature:\n'
+            'value}`` mapping, or a Configuration object. ``test_case_path`` is optional\n'
+            'and, when given, diagnoses against that expected outcome instead; it accepts\n'
+            'the same input types.'
+        ),
+        returns='Union[None, List[str]]',
+        name='diagnosis', operation='PySATDiagnosis', default_backend='pysat_diagnosis',
+        inputs=(
+            Input('configuration_path', str, required=True, kind='configuration',
+                  setter='set_configuration'),
+            Input('test_case_path', str, default=None, kind='configuration',
+                  setter='set_test_case'),
+            Input('max_diagnoses', int, default=None, setter='set_max_diagnoses'),
+        ),
+    )
+
     def __init__(self) -> None:
         super().__init__()
         self.max_diagnoses = -1  # -1 means no limit

flamapy_sat-2.6.0/flamapy/metamodels/pysat_diagnosis_metamodel/transformations/fm_to_diag_pysat.py

@@ -0,0 +1,37 @@
+from flamapy.metamodels.fm_metamodel.models import FeatureModel, ClauseSet
+from flamapy.metamodels.pysat_metamodel.transformations.fm_to_pysat import FmToPysat
+from ..models.pysat_diagnosis_model import DiagnosisModel
+
+
+class FmToDiagPysat(FmToPysat):
+    """Like FmToPysat, but into a DiagnosisModel that also keeps a clause → constraint map.
+
+    The CNF and its per-source clause grouping both come from the shared feature-model encoder
+    (``ClauseSet``); this transformation just wraps them into the diagnosis model.
+    """
+
+    @staticmethod
+    def get_source_extension() -> str:
+        return 'fm'
+
+    @staticmethod
+    def get_destination_extension() -> str:
+        return 'pysat_diagnosis'
+
+    def __init__(self, source_model: FeatureModel, cnf_method: str = 'distributive') -> None:
+        super().__init__(source_model, cnf_method)
+        self.destination_model = DiagnosisModel()
+
+    def transform(self) -> DiagnosisModel:
+        clause_set = ClauseSet.from_feature_model(self.source_model, cnf_method=self.cnf_method)
+        model = self.destination_model
+        for clause in clause_set.clauses:
+            model.add_clause(clause)
+        model.variables = dict(clause_set.variables)
+        model.features = dict(clause_set.features)
+        model.auxiliary_variables = set(clause_set.auxiliary_variables)
+        model.original_model = self.source_model
+        # Clause → constraint mapping (root feature / relations / cross-tree constraints).
+        for description, clauses in clause_set.clause_groups:
+            model.add_clause_to_map(description, clauses)
+        return model

{flamapy_sat-2.5.0.dev0 → flamapy_sat-2.6.0}/flamapy/metamodels/pysat_metamodel/models/pysat_model.py

@@ -13,6 +13,9 @@ class PySATModel(VariabilityModel):
         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()
         self.original_model: VariabilityModel
 
     def add_clause(self, clause: list[int]) -> None:

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

@@ -4,13 +4,19 @@ from .pysat_configurations import PySATConfigurations
 from .pysat_configurations_number import PySATConfigurationsNumber
 from .pysat_commonality import PySATCommonality
 from .pysat_filter import PySATFilter
+from .pysat_backbone import PySATBackbone
 from .pysat_core_features import PySATCoreFeatures
 from .pysat_dead_features import PySATDeadFeatures
 from .pysat_false_optional_features import PySATFalseOptionalFeatures
 from .pysat_metrics import PySATMetrics
+from .pysat_attribute_optimization import PySATAttributeOptimization
+from .pysat_minimum_configuration import PySATMinimumConfiguration
+from .pysat_twise_sampling import PySATTWiseSampling
 
 
 __all__ = [
+    'PySATAttributeOptimization',
+    'PySATBackbone',
     'PySATCommonality',
     'PySATConfigurations',
     'PySATConfigurationsNumber',
@@ -19,6 +25,8 @@ __all__ = [
     'PySATFalseOptionalFeatures',
     'PySATFilter',
     'PySATMetrics',
+    'PySATMinimumConfiguration',
     'PySATSatisfiable',
     'PySATSatisfiableConfiguration',
+    'PySATTWiseSampling',
 ]

flamapy_sat-2.6.0/flamapy/metamodels/pysat_metamodel/operations/pysat_attribute_optimization.py

@@ -0,0 +1,127 @@
+from typing import Any, Optional, cast
+
+from pysat.formula import WCNF
+from pysat.examples.rc2 import RC2
+
+from flamapy.core.models import VariabilityModel
+from flamapy.core.operations import AttributeOptimization, OptimizationGoal
+from flamapy.core.exceptions import FlamaException
+from flamapy.metamodels.configuration_metamodel.models.configuration import Configuration
+from flamapy.metamodels.fm_metamodel.models.feature_model import FeatureModel
+from flamapy.metamodels.pysat_metamodel.models.pysat_model import PySATModel
+
+
+class PySATAttributeOptimization(AttributeOptimization):
+    """Optimal configuration for a single numeric feature attribute, via MaxSAT (RC2).
+
+    The objective is the sum of the attribute value over the selected features. The SAT
+    clauses are the hard constraints; per-feature attribute values become weighted soft
+    clauses so RC2 returns a valid configuration with the optimal objective.
+
+    Multi-objective/Pareto optimization is not supported here — use the z3 backend for that.
+    """
+
+    def __init__(self) -> None:
+        self._attributes: dict[str, OptimizationGoal] = {}
+        self._result: list[Configuration] = []
+        self._optimum: dict[str, float] = {}
+
+    def set_attributes(self, attributes: dict[str, OptimizationGoal]) -> None:
+        self._attributes = attributes
+
+    def optimize(self) -> list[Configuration]:
+        return self.get_result()
+
+    def get_result(self) -> list[Configuration]:
+        return self._result
+
+    def get_optimum(self) -> dict[str, float]:
+        """The optimal objective value per attribute, e.g. ``{'Cost': 12.0}``."""
+        return self._optimum
+
+    def execute(self, model: VariabilityModel) -> 'PySATAttributeOptimization':
+        sat_model = cast(PySATModel, model)
+        if len(self._attributes) != 1:
+            raise FlamaException(
+                'PySATAttributeOptimization optimizes a single attribute; use the z3 '
+                'backend for multi-objective/Pareto optimization.'
+            )
+        (attr_name, goal), = self._attributes.items()
+        feature_model = getattr(sat_model, 'original_model', None)
+        if feature_model is None:
+            raise FlamaException(
+                'The SAT model has no attached feature model to read attributes from.'
+            )
+        weights = _feature_weights(cast(FeatureModel, feature_model), attr_name)
+        config, optimum = _optimize(sat_model, weights, goal)
+        if config is None or optimum is None:
+            self._result = []
+            self._optimum = {}
+        else:
+            self._result = [config]
+            self._optimum = {attr_name: optimum}
+        return self
+
+
+def _feature_weights(feature_model: FeatureModel, attribute_name: str) -> dict[str, float]:
+    """Map each feature carrying the given numeric attribute to its value."""
+    weights: dict[str, float] = {}
+    for feature in feature_model.get_features():
+        for attribute in feature.get_attributes():
+            value = attribute.default_value
+            if attribute.name == attribute_name and isinstance(value, (int, float)) \
+                    and not isinstance(value, bool):
+                weights[feature.name] = float(value)
+    return weights
+
+
+def _integer_scale(values: list[float]) -> int:
+    """Smallest power of ten that turns all values into integers (capped at 1e6)."""
+    max_decimals = 0
+    for value in values:
+        text = f"{value:.6f}".rstrip('0')
+        if '.' in text:
+            max_decimals = max(max_decimals, len(text.split('.')[1]))
+    return 10 ** max_decimals
+
+
+def _optimize(sat_model: PySATModel,
+              weights: dict[str, float],
+              goal: OptimizationGoal) -> tuple[Optional[Configuration], Optional[float]]:
+    # Maximizing an objective is minimizing its negation.
+    sign = 1.0 if goal == OptimizationGoal.MINIMIZE else -1.0
+    effective = {name: sign * weight for name, weight in weights.items()}
+    scale = _integer_scale(list(effective.values()))
+
+    wcnf = WCNF()
+    for clause in sat_model.get_all_clauses():
+        wcnf.append(list(clause))  # hard clauses
+
+    for name, weight in effective.items():
+        variable = sat_model.variables.get(name)
+        if variable is None:
+            continue
+        int_weight = round(weight * scale)
+        if int_weight > 0:
+            # Cost paid when the feature is selected -> pushes it out to reduce the objective.
+            wcnf.append([-variable], weight=int_weight)
+        elif int_weight < 0:
+            # Cost paid when the feature is deselected -> pulls it in.
+            wcnf.append([variable], weight=-int_weight)
+
+    with RC2(wcnf) as rc2:
+        assignment = rc2.compute()
+        if assignment is None:
+            return None, None
+        selected_vars = {literal for literal in assignment if literal > 0}
+        elements: dict[Any, Any] = {}
+        for literal in assignment:
+            if literal > 0:
+                feature_name = sat_model.features.get(literal)
+                if feature_name is not None:  # skip auxiliary variables
+                    elements[feature_name] = True
+        configuration = Configuration(elements)
+
+    optimum = sum(weight for name, weight in weights.items()
+                  if sat_model.variables.get(name) in selected_vars)
+    return configuration, optimum

flamapy_sat-2.6.0/flamapy/metamodels/pysat_metamodel/operations/pysat_backbone.py

@@ -0,0 +1,83 @@
+from typing import Any, cast
+
+from pysat.solvers import Solver
+
+from flamapy.core.operations import Operation
+from flamapy.core.operations.descriptor import OperationDescriptor
+from flamapy.metamodels.pysat_metamodel.models.pysat_model import PySATModel
+from flamapy.core.models import VariabilityModel
+
+
+class PySATBackbone(Operation):
+    facade = OperationDescriptor(
+        doc=(
+            'Returns the backbone of the feature model: the set of features that must\n'
+            'always be selected (core) and those that must never be selected (dead) across\n'
+            "all valid configurations, grouped under 'core' and 'dead' keys."
+        ),
+        returns='Union[None, Dict[str, List[Any]]]',
+        name='backbone', operation='PySATBackbone', default_backend='sat'
+    )
+
+    def __init__(self) -> None:
+        self._result: dict[str, list[Any]] = {"core": [], "dead": []}
+
+
+    def get_backbone(self) -> dict[str, list[Any]]:
+        return self.get_result()
+
+    def get_result(self) -> dict[str, list[Any]]:
+        return self._result
+
+    def execute(self, model: VariabilityModel) -> 'PySATBackbone':
+        sat_model = cast(PySATModel, model)
+        self._result = get_backbone(sat_model)
+        return self
+
+
+def get_backbone(model: PySATModel) -> dict[str, list[Any]]:
+    # B <- Ø
+    backbone_core = []
+    backbone_dead = []
+
+    id_to_name = model.features
+    relevant_ids = set(id_to_name.keys())
+
+    solver = Solver(name='glucose3')
+    for clause in model.get_all_clauses().clauses:
+        solver.add_clause(clause)
+
+    # (out, C) <- SAT(phi)
+    if not solver.solve():
+        solver.delete()
+        return {"core": [], "dead": list(id_to_name.values())}
+
+    # 3. C <- filter(C)
+    initial_model = solver.get_model()
+    candidates = {lit for lit in initial_model if abs(lit) in relevant_ids}
+
+    # while C != Ø do
+    while candidates:
+        # l <- pick a literal from C
+        literal = next(iter(candidates))
+
+        # (out, S) <- SAT(phi U {not l})
+        if not solver.solve(assumptions=[-literal]):
+            # out = unsat -> l is in the backbone
+            name = id_to_name[abs(literal)]
+            if literal > 0:
+                backbone_core.append(name)
+            else:
+                backbone_dead.append(name)
+
+            # C <- C \ {l}
+            candidates.remove(literal)
+
+            # phi <- phi U {l}
+            solver.add_clause([literal])
+        else:
+            new_model_set = set(solver.get_model())
+            # C <- C ∩ S
+            candidates &= new_model_set
+    solver.delete()
+    return {"core": backbone_core, "dead": backbone_dead}