flamapy-z3 2.6.0.dev12__tar.gz → 2.9.0.dev0__tar.gz

{flamapy_z3-2.6.0.dev12 → flamapy_z3-2.9.0.dev0}/PKG-INFO

@@ -1,14 +1,14 @@
 Metadata-Version: 2.4
 Name: flamapy-z3
-Version: 2.6.0.dev12
+Version: 2.9.0.dev0
 Summary: z3-plugin for the automated analysis of feature models
 Author-email: Flamapy <flamapy@us.es>
 License-Expression: GPL-3.0-or-later
 Project-URL: Homepage, https://github.com/flamapy/z3_metamodel
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
-Requires-Dist: flamapy-fw~=2.6.0.dev12
-Requires-Dist: flamapy-fm~=2.6.0.dev12
+Requires-Dist: flamapy-fw~=2.9.0.dev0
+Requires-Dist: flamapy-fm~=2.9.0.dev0
 Requires-Dist: z3-solver~=4.14.1.0
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
@@ -16,6 +16,8 @@ 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"
 
 # flamapy-z3
 

flamapy_z3-2.9.0.dev0/flamapy/metamodels/z3_metamodel/__init__.py

@@ -0,0 +1,36 @@
+from flamapy.core.manifest import OperationCapability, PluginManifest
+from flamapy.core.models.language_level import LanguageLevel, MajorLevel, MinorLevel
+
+# The SMT backend for typed/attributed feature models (TYPE major level). 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, never decreasing): building
+# the solver and the satisfiability/implication queries scale to 10,000 features, false-optional
+# detection reaches 11 s there, and listing or counting configurations enumerates the models one
+# by one (0.9 s already on the 20-feature calibration model).
+_IMPLICATION_QUERIES = ((100, 1), (200, 3), (500, 9), (1000, 20), (5000, 41), (10000, 100))
+_SAT_QUERY = ((200, 1), (500, 4), (1000, 6), (2000, 16), (10000, 40))
+
+MANIFEST = PluginManifest(
+    name='z3',
+    calibration='2026-11-06',
+    extension='z3',
+    supported_level=LanguageLevel(MajorLevel.TYPE, {
+        MinorLevel.STRING_CONSTRAINTS, MinorLevel.AGGREGATE_FUNCTION,
+        MinorLevel.GROUP_CARDINALITY}),
+    transformation_cost_curve=((1000, 54), (2000, 88), (5000, 120), (10000, 250)),
+    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=((50, 2), (100, 3), (200, 8), (500, 29), (1000, 100), (2000, 420),
+                        (5000, 2100), (10000, 11000))),
+        'configurations_number': OperationCapability(max_features=30, cost=900),
+        'configurations': OperationCapability(max_features=30, cost=900),
+        'feature_bounds': OperationCapability(),
+        'all_feature_bounds': OperationCapability(),
+        # Single- and multi-objective (Pareto) optimization over typed attributes.
+        'attribute_optimization': OperationCapability(),
+    },
+)

flamapy_z3-2.9.0.dev0/flamapy/metamodels/z3_metamodel/operations/z3_backbone.py

@@ -0,0 +1,53 @@
+from typing import Any, cast
+
+import z3
+
+from flamapy.core.models import VariabilityModel
+from flamapy.core.operations import Operation
+from flamapy.metamodels.z3_metamodel.models import Z3Model
+
+
+class Z3Backbone(Operation):
+
+    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) -> 'Z3Backbone':
+        z3_model = cast(Z3Model, model)
+        self._result = get_backbone(z3_model)
+        return self
+
+
+def get_backbone(model: Z3Model) -> dict[str, list[Any]]:
+    """Core and dead features: the literals over the selection variables that the model implies.
+
+    `Solver.consequences` computes every implied literal among the given variables in one call,
+    inside the solver (models prune the candidates and unsatisfiable cores prove the rest), so no
+    per-feature check is needed. It also works on typed models, where the implications may
+    depend on the arithmetic and string constraints. An unsatisfiable model has no core
+    features and every feature dead, as in the SAT plugin.
+    """
+    solver = z3.Solver(ctx=model.ctx)
+    solver.add(model.constraints)
+    selections = [info.sel for info in model.features.values()]
+    names = {info.sel.get_id(): name for name, info in model.features.items()}
+    status, implied = solver.consequences([], selections)
+    if status != z3.sat:
+        return {"core": [], "dead": list(model.features.keys())}
+    core: list[Any] = []
+    dead: list[Any] = []
+    for consequence in implied:  # each one is Implies(And(<assumptions>), literal)
+        literal = consequence.arg(1)
+        if z3.is_not(literal):
+            dead.append(names[literal.arg(0).get_id()])
+        else:
+            core.append(names[literal.get_id()])
+    order = {name: index for index, name in enumerate(model.features)}
+    return {"core": sorted(core, key=order.__getitem__),
+            "dead": sorted(dead, key=order.__getitem__)}

{flamapy_z3-2.6.0.dev12 → flamapy_z3-2.9.0.dev0}/flamapy_z3.egg-info/PKG-INFO

@@ -1,14 +1,14 @@
 Metadata-Version: 2.4
 Name: flamapy-z3
-Version: 2.6.0.dev12
+Version: 2.9.0.dev0
 Summary: z3-plugin for the automated analysis of feature models
 Author-email: Flamapy <flamapy@us.es>
 License-Expression: GPL-3.0-or-later
 Project-URL: Homepage, https://github.com/flamapy/z3_metamodel
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
-Requires-Dist: flamapy-fw~=2.6.0.dev12
-Requires-Dist: flamapy-fm~=2.6.0.dev12
+Requires-Dist: flamapy-fw~=2.9.0.dev0
+Requires-Dist: flamapy-fm~=2.9.0.dev0
 Requires-Dist: z3-solver~=4.14.1.0
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
@@ -16,6 +16,8 @@ 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"
 
 # flamapy-z3
 

{flamapy_z3-2.6.0.dev12 → flamapy_z3-2.9.0.dev0}/flamapy_z3.egg-info/SOURCES.txt

@@ -24,7 +24,9 @@ flamapy/metamodels/z3_metamodel/transformations/fm_to_z3.py
 flamapy_z3.egg-info/PKG-INFO
 flamapy_z3.egg-info/SOURCES.txt
 flamapy_z3.egg-info/dependency_links.txt
+flamapy_z3.egg-info/entry_points.txt
 flamapy_z3.egg-info/requires.txt
 flamapy_z3.egg-info/top_level.txt
 tests/test_tseytin.py
+tests/test_z3_backbone.py
 tests/test_z3_metamodel.py

flamapy_z3-2.9.0.dev0/flamapy_z3.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[flamapy.plugins]
+z3 = flamapy.metamodels.z3_metamodel

{flamapy_z3-2.6.0.dev12 → flamapy_z3-2.9.0.dev0}/flamapy_z3.egg-info/requires.txt

@@ -1,5 +1,5 @@
-flamapy-fw~=2.6.0.dev12
-flamapy-fm~=2.6.0.dev12
+flamapy-fw~=2.9.0.dev0
+flamapy-fm~=2.9.0.dev0
 z3-solver~=4.14.1.0
 
 [dev]
@@ -8,3 +8,6 @@ pytest-mock
 prospector
 mypy
 coverage
+
+[test]
+pytest

{flamapy_z3-2.6.0.dev12 → flamapy_z3-2.9.0.dev0}/pyproject.toml

@@ -4,15 +4,15 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "flamapy-z3"
-version = "2.6.0.dev12"
+version = "2.9.0.dev0"
 description = "z3-plugin for the automated analysis of feature models"
 readme = "README.md"
 license = "GPL-3.0-or-later"
 authors = [{ name = "Flamapy", email = "flamapy@us.es" }]
 requires-python = ">=3.11"
 dependencies = [
-    "flamapy-fw~=2.6.0.dev12",
-    "flamapy-fm~=2.6.0.dev12",
+    "flamapy-fw~=2.9.0.dev0",
+    "flamapy-fm~=2.9.0.dev0",
     "z3-solver~=4.14.1.0",
 ]
 
@@ -25,6 +25,14 @@ dev = [
     "coverage",
 ]
 
+# The suite needs no sibling plugin beyond flamapy-fm.
+test = [
+    "pytest",
+]
+
+[project.entry-points."flamapy.plugins"]
+z3 = "flamapy.metamodels.z3_metamodel"
+
 [project.urls]
 Homepage = "https://github.com/flamapy/z3_metamodel"
 

flamapy_z3-2.9.0.dev0/tests/test_z3_backbone.py

@@ -0,0 +1,57 @@
+"""Backbone (core and dead features) through z3's consequences API, on Boolean and typed models.
+
+The expected values were produced by the previous implementation (one check per candidate
+literal) and cross-checked by hand on the small models.
+"""
+import pytest
+
+from flamapy.metamodels.fm_metamodel.transformations import UVLReader
+from flamapy.metamodels.z3_metamodel.transformations import FmToZ3
+from flamapy.metamodels.z3_metamodel.operations import (
+    Z3Backbone,
+    Z3CoreFeatures,
+    Z3DeadFeatures,
+)
+
+
+MODELS = 'resources/models/uvl_models/'
+
+ELECTRICITY_CORE = ['DATE', 'DAY', 'DAY_NAME', 'DEMAND', 'Electricity_price', 'INFORMATION_TYPE',
+                    'MONTH', 'Period', 'USEP', 'YEAR']
+
+
+@pytest.mark.parametrize('path, core, dead', [
+    (MODELS + 'Electricity.uvl', ELECTRICITY_CORE, []),
+    (MODELS + 'Electricity_with_deadfeature.uvl', ELECTRICITY_CORE, ['ok']),
+    (MODELS + 'Electricity_with_no_deadfeature.uvl', [*ELECTRICITY_CORE, 'ok'], []),
+    (MODELS + 'Pizza_z3.uvl',
+     ['Dough', 'Normal', 'Pizza', 'Size', 'SpicyLvl', 'Topping'], ['Big', 'Name']),
+    (MODELS + 'fm03_integer_conditional_bounded.uvl', ['Container', 'Icecream', 'Scoops'], ['Stick']),
+    (MODELS + 'fm04_integer_dead_feature.uvl', ['Container', 'Icecream'], ['Scoops']),
+    (MODELS + 'fm13_feature_cardinality_bounded_refactored.uvl', ['R'], ['D']),
+    (MODELS + 'numerical_core_feature.uvl', ['Electricity_price', 'Period', 'ok'], []),
+    (MODELS + 'group_cardinalities.uvl', ['root'], []),
+    (MODELS + 'mutex.uvl', ['root'], []),
+])
+def test_backbone(path: str, core: list, dead: list):
+    z3_model = FmToZ3(UVLReader(path).transform()).transform()
+    backbone = Z3Backbone().execute(z3_model).get_result()
+    assert sorted(backbone['core']) == sorted(core)
+    assert sorted(backbone['dead']) == sorted(dead)
+    assert Z3CoreFeatures().execute(z3_model).get_result() == backbone['core']
+    assert Z3DeadFeatures().execute(z3_model).get_result() == backbone['dead']
+
+
+def test_backbone_follows_the_feature_order():
+    z3_model = FmToZ3(UVLReader(MODELS + 'Pizza_z3.uvl').transform()).transform()
+    order = list(z3_model.features)
+    backbone = Z3Backbone().execute(z3_model).get_result()
+    assert backbone['core'] == sorted(backbone['core'], key=order.index)
+    assert backbone['dead'] == sorted(backbone['dead'], key=order.index)
+
+
+def test_void_model_has_no_core_and_every_feature_dead():
+    z3_model = FmToZ3(UVLReader(MODELS + 'Electricity_unsat.uvl').transform()).transform()
+    backbone = Z3Backbone().execute(z3_model).get_result()
+    assert backbone['core'] == []
+    assert backbone['dead'] == list(z3_model.features)

flamapy_z3-2.6.0.dev12/flamapy/metamodels/z3_metamodel/operations/z3_backbone.py

@@ -1,70 +0,0 @@
-from typing import Any, cast
-
-import z3
-
-from flamapy.core.models import VariabilityModel
-from flamapy.core.operations import Operation
-from flamapy.metamodels.z3_metamodel.models import Z3Model
-
-
-class Z3Backbone(Operation):
-
-    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) -> 'Z3Backbone':
-        z3_model = cast(Z3Model, model)
-        self._result = get_backbone(z3_model)
-        return self
-
-
-def get_backbone(model: Z3Model) -> dict[str, list[Any]]:
-    solver = z3.Solver(ctx=model.ctx)
-    solver.add(model.constraints)
-
-    vars_to_features = {f_info.sel: name for name, f_info in model.features.items()}
-
-    # (out, C) <- SAT(phi)
-    if solver.check() != z3.sat:
-        return {"core": [], "dead": list(model.features.keys())}
-
-    m = solver.model()
-    # C <- filter(C)
-    core_candidates = {var for var in vars_to_features.keys() if z3.is_true(m[var])}
-    dead_candidates = {var for var in vars_to_features.keys() if z3.is_false(m[var])}
-
-    backbone_core = []
-    backbone_dead = []
-
-    while core_candidates or dead_candidates:
-        if core_candidates:
-            literal = next(iter(core_candidates))
-            check_lit = z3.Not(literal)
-            is_core = True
-        else:
-            literal = next(iter(dead_candidates))
-            check_lit = literal
-            is_core = False
-
-        # (out, S) <- SAT(phi U {not l})
-        if solver.check([check_lit]) == z3.unsat:
-            if is_core:
-                backbone_core.append(vars_to_features[literal])
-                solver.add(literal)
-                core_candidates.remove(literal)
-            else:
-                backbone_dead.append(vars_to_features[literal])
-                solver.add(z3.Not(literal))
-                dead_candidates.remove(literal)
-        else:
-            new_model = solver.model()
-            core_candidates = {var for var in core_candidates if z3.is_true(new_model[var])}
-            dead_candidates = {var for var in dead_candidates if z3.is_false(new_model[var])}
-
-    return {"core": backbone_core, "dead": backbone_dead}