action-rules 2.0.1__tar.gz → 2.1.0__tar.gz

{action_rules-2.0.1 → action_rules-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: action-rules
-Version: 2.0.1
+Version: 2.1.0
 Summary: The package for action rules mining using Action-Apriori (Apriori Modified for Action Rules Mining)..
 License: MIT
 License-File: LICENSE
@@ -18,6 +18,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
 Provides-Extra: dev
 Provides-Extra: doc
 Provides-Extra: inference
@@ -42,7 +43,7 @@ Requires-Dist: pandas (>=2.2.2,<3.0.0)
 Requires-Dist: pip (>=24.0,<25.0) ; extra == "dev"
 Requires-Dist: pre-commit (>=3.7.1,<4.0.0) ; extra == "dev"
 Requires-Dist: pytest (>=8.2.1,<9.0.0) ; extra == "test"
-Requires-Dist: pytest-cov (>=5.0.0,<6.0.0) ; extra == "test"
+Requires-Dist: pytest-cov (>=5.0.0,<8.0.0) ; extra == "test"
 Requires-Dist: scipy (>=1.10,<2.0) ; extra == "test" or extra == "inference" or extra == "viz"
 Requires-Dist: toml (>=0.10.2,<0.11.0) ; extra == "dev"
 Requires-Dist: tox (>=4.15.0,<5.0.0) ; extra == "dev"

{action_rules-2.0.1 → action_rules-2.1.0}/pyproject.toml

@@ -1,7 +1,7 @@
 [tool]
 [tool.poetry]
 name = "action-rules"
-version = "2.0.1"
+version = "2.1.0"
 homepage = "https://github.com/lukassykora/action-rules"
 description = "The package for action rules mining using Action-Apriori (Apriori Modified for Action Rules Mining).."
 authors = ["Lukas Sykora <lukas.sykora@vse.cz>"]
@@ -31,7 +31,7 @@ flake8  = { version = "^7.0.0", optional = true}
 flake8-docstrings = { version = "^1.7.0", optional = true }
 mypy = {version = "^1.10.0", optional = true}
 pytest  = { version = "^8.2.1", optional = true}
-pytest-cov  = { version = "^5.0.0", optional = true}
+pytest-cov  = { version = ">=5.0.0,<8.0.0", optional = true}
 scipy = { version = "^1.10", optional = true}
 matplotlib = { version = "^3.7", optional = true}
 tox  = { version = "^4.15.0", optional = true}

{action_rules-2.0.1 → action_rules-2.1.0}/src/action_rules/__init__.py

@@ -17,4 +17,4 @@ __all__ = [
 ]
 __author__ = """Lukas Sykora"""
 __email__ = 'lukas.sykora@vse.cz'
-__version__ = '2.0.1'
+__version__ = '2.1.0'

{action_rules-2.0.1 → action_rules-2.1.0}/src/action_rules/action_rules.py

@@ -908,6 +908,11 @@ class ActionRules:
         random_state: Optional[int] = None,
         analytic_type: str = "wald",
         bootstrap_type: str = "percentile",
+        *,
+        prior: Optional[str] = None,
+        simultaneous_m: Optional[int] = None,
+        resample_mode: str = "rows",
+        discovery_fraction: float = 0.5,
     ):
         r"""Compute confidence intervals for all fitted action rules.
 
@@ -999,7 +1004,15 @@ class ActionRules:
             raise ValueError("n_bootstrap must be >= 1.")
         if n_mc < 1:
             raise ValueError("n_mc must be >= 1.")
-        valid_analytic_types = {"wald", "wilson", "newcombe_wilson", "auto"}
+        valid_analytic_types = {
+            "wald",
+            "wald_rd",
+            "wald_random",
+            "wilson",
+            "newcombe_wilson",
+            "clopper_pearson",
+            "auto",
+        }
         if analytic_type not in valid_analytic_types:
             raise ValueError(f"Unknown analytic_type '{analytic_type}'. Choose from {valid_analytic_types}.")
         valid_bootstrap_types = {"percentile", "bca"}
@@ -1012,27 +1025,52 @@ class ActionRules:
         from .inference.base import categorize_rule, extract_rule_masks
 
         masks = extract_rule_masks(self.output)
+        eval_data = data
 
         engine: Any
-        if method == "bootstrap":
+        if method in ("bootstrap", "bca"):
             from .inference.bootstrap import BootstrapEngine
 
-            engine = BootstrapEngine(n_bootstrap, random_state, bootstrap_type=bootstrap_type)
-        elif method in ("analytic", "wald"):
+            eff_btype = "bca" if method == "bca" else bootstrap_type
+            engine = BootstrapEngine(
+                n_bootstrap,
+                random_state,
+                bootstrap_type=eff_btype,
+                resample_mode=resample_mode,
+            )
+        elif method in ("analytic", "wald", "wald_rd", "wald_random", "wilson", "newcombe_wilson", "clopper_pearson", "auto"):
             from .inference.analytic import AnalyticEngine
 
-            engine = AnalyticEngine(analytic_type=analytic_type)
-        elif method == "bayesian":
+            eff_atype = analytic_type if method in ("analytic", "wald") else method
+            engine = AnalyticEngine(analytic_type=eff_atype, simultaneous_m=simultaneous_m)
+        elif method in ("bayesian", "jeffreys"):
             from .inference.bayesian import BayesianEngine
 
-            engine = BayesianEngine(n_mc, random_state=random_state)
+            eff_prior = "jeffreys" if method == "jeffreys" else prior
+            engine = BayesianEngine(n_mc, random_state=random_state, prior=eff_prior)
+        elif method == "honest_split":
+            if not (0.0 < discovery_fraction < 1.0):
+                raise ValueError("discovery_fraction must be strictly between 0 and 1.")
+            import numpy as _np
+
+            from .inference.analytic import AnalyticEngine
+
+            rng_split = _np.random.default_rng(random_state)
+            n_rows = len(data)
+            perm = rng_split.permutation(n_rows)
+            n_disc = int(round(discovery_fraction * n_rows))
+            est_idx = perm[n_disc:]
+            eval_data = data.iloc[est_idx].reset_index(drop=True) if len(est_idx) > 0 else data
+            eff_atype = "newcombe_wilson" if analytic_type == "wald" else analytic_type
+            engine = AnalyticEngine(analytic_type=eff_atype, simultaneous_m=simultaneous_m)
         else:
             raise ValueError(
-                f"Unknown method '{method}'. Supported methods: 'bootstrap', 'analytic', 'wald', 'bayesian'."
+                f"Unknown method '{method}'. Supported methods: 'bootstrap', 'bca', 'analytic', 'wald', "
+                f"'wald_rd', 'newcombe_wilson', 'clopper_pearson', 'auto', 'bayesian', 'jeffreys', 'honest_split'."
             )
 
         results = engine.compute(
-            data=data,
+            data=eval_data,
             rules=masks,
             confidence_level=confidence_level,
             intrinsic_utility_table=self._original_intrinsic_utility_table or None,

{action_rules-2.0.1 → action_rules-2.1.0}/src/action_rules/inference/analytic.py

@@ -88,7 +88,7 @@ class AnalyticEngine(InferenceEngine):
     # Initialisation
     # ------------------------------------------------------------------
 
-    def __init__(self, analytic_type: str = "wald") -> None:
+    def __init__(self, analytic_type: str = "wald", simultaneous_m: Optional[int] = None) -> None:
         r"""Initialise the engine with the chosen interval type.
 
         Parameters
@@ -97,31 +97,50 @@ class AnalyticEngine(InferenceEngine):
             Which closed-form interval to use.  One of:
 
             ``'wald'``
-                Standard Wald (normal approximation) interval.  Default and
-                backward-compatible choice.
+                Standard Wald (normal approximation) interval under fixed-
+                antecedent conditioning.  Default and backward-compatible choice.
+            ``'wald_rd'`` or ``'wald_random'``
+                Random-design (RD) delta-method Wald interval that propagates
+                uncertainty in the antecedent prevalence :math:`\hat{q}_u = n_u / N`
+                alongside the conditional proportions :math:`\hat{p}_u, \hat{p}_d`.
             ``'newcombe_wilson'`` (preferred) or ``'wilson'`` (alias)
                 Newcombe-Wilson interval for the unscaled rule contrast
-                :math:`\\delta = p_d + p_u - 1` (Newcombe, 1998), built by
+                :math:`\delta = p_d + p_u - 1` (Newcombe, 1998), built by
                 combining two single-proportion Wilson score intervals.
                 More accurate for small samples or proportions near 0 or 1.
                 ``'wilson'`` is retained as a backward-compatible alias and
                 resolves to the same Newcombe-Wilson construction.
+            ``'clopper_pearson'``
+                Exact Clopper-Pearson single-proportion intervals combined via
+                Newcombe's square-and-add root.
             ``'auto'``
                 Selects the Newcombe-Wilson branch when either side has
                 ``n < 40`` or ``p < 0.05`` / ``p > 0.95``; falls back to
                 Wald otherwise (Agresti & Coull, 1998).
+        simultaneous_m : int, optional
+            When provided (``>= 1``), applies a Bonferroni simultaneous
+            multiplicity correction over *simultaneous_m* candidate rules by
+            setting :math:`\alpha_{\mathrm{eff}} = (1 - \text{confidence\_level}) / m`.
 
         Raises
         ------
         ValueError
-            If *analytic_type* is not one of the recognised values.
+            If *analytic_type* is not one of the recognised values or
+            *simultaneous_m* is less than 1.
         """
-        valid = {"wald", "wilson", "newcombe_wilson", "auto"}
+        valid = {"wald", "wald_rd", "wald_random", "wilson", "newcombe_wilson", "clopper_pearson", "auto"}
         if analytic_type not in valid:
             raise ValueError(f"Unknown analytic_type '{analytic_type}'. Choose from {valid}.")
-        # Canonicalise: 'wilson' is a backward-compatible alias for
-        # 'newcombe_wilson'.  Both invoke the same Newcombe-Wilson code path.
-        self.analytic_type = "newcombe_wilson" if analytic_type == "wilson" else analytic_type
+        if simultaneous_m is not None and simultaneous_m < 1:
+            raise ValueError(f"simultaneous_m must be >= 1, got {simultaneous_m}.")
+        # Canonicalise aliases
+        if analytic_type == "wilson":
+            self.analytic_type = "newcombe_wilson"
+        elif analytic_type == "wald_random":
+            self.analytic_type = "wald_rd"
+        else:
+            self.analytic_type = analytic_type
+        self.simultaneous_m = simultaneous_m
 
     # ------------------------------------------------------------------
     # Private helpers
@@ -206,6 +225,38 @@ class AnalyticEngine(InferenceEngine):
         upper = delta_hat + sqrt((u_d - p_d) ** 2 + (u_u - p_u) ** 2)
         return delta_hat, lower, upper
 
+    @staticmethod
+    def _clopper_pearson_bounds(x: float, n: float, alpha: float) -> Tuple[float, float, float]:
+        """Single-proportion exact Clopper-Pearson interval (Clopper & Pearson, 1934).
+
+        Parameters
+        ----------
+        x : float
+            Number of successes.
+        n : float
+            Number of trials.
+        alpha : float
+            Two-sided significance level ``1 - confidence_level``.
+
+        Returns
+        -------
+        p_hat : float
+            Maximum-likelihood proportion ``x / n``.
+        lower : float
+            Exact Clopper-Pearson lower bound.
+        upper : float
+            Exact Clopper-Pearson upper bound.
+        """
+        if n <= 0:
+            nan = float('nan')
+            return nan, nan, nan
+        from scipy.stats import beta
+
+        p_hat = x / n
+        lower = 0.0 if x <= 0 else float(beta.ppf(alpha / 2.0, x, n - x + 1.0))
+        upper = 1.0 if x >= n else float(beta.ppf(1.0 - alpha / 2.0, x + 1.0, n - x))
+        return p_hat, lower, upper
+
     # ------------------------------------------------------------------
     # Public API
     # ------------------------------------------------------------------
@@ -265,6 +316,8 @@ class AnalyticEngine(InferenceEngine):
         compute_gain = (intrinsic_utility_table is not None) or (transition_utility_table is not None)
 
         alpha = 1.0 - confidence_level
+        if self.simultaneous_m is not None and self.simultaneous_m > 1:
+            alpha = alpha / float(self.simultaneous_m)
         z = norm.ppf(1.0 - alpha / 2.0)
 
         results: List[ConfidenceIntervalResult] = []
@@ -313,7 +366,17 @@ class AnalyticEngine(InferenceEngine):
                 and (n_u_ante < 40 or n_d_ante < 40 or p_u < 0.05 or p_u > 0.95 or p_d < 0.05 or p_d > 0.95)
             )
 
-            if use_wilson:
+            var_p_u = p_u * (1.0 - p_u) / n_u_ante
+            var_p_d = p_d * (1.0 - p_d) / n_d_ante
+            var_delta = var_p_u + var_p_d
+
+            if self.analytic_type == "clopper_pearson":
+                _, l_u, u_u = self._clopper_pearson_bounds(n_u_match, n_u_ante, alpha)
+                _, l_d, u_d = self._clopper_pearson_bounds(n_d_match, n_d_ante, alpha)
+                _, delta_lower, delta_upper = self._newcombe_delta_interval(
+                    p_u, l_u, u_u, p_d, l_d, u_d
+                )
+            elif use_wilson:
                 # Newcombe (1998) combination of single-proportion Wilson intervals.
                 _, l_u, u_u = self._wilson_bounds(n_u_match, n_u_ante, z)
                 _, l_d, u_d = self._wilson_bounds(n_d_match, n_d_ante, z)
@@ -322,21 +385,25 @@ class AnalyticEngine(InferenceEngine):
                 )
             else:
                 # Wald delta-method interval for delta = p_d + p_u - 1.
-                var_p_u = p_u * (1.0 - p_u) / n_u_ante
-                var_p_d = p_d * (1.0 - p_d) / n_d_ante
-                var_delta = var_p_u + var_p_d
                 delta_se = sqrt(var_delta)
                 delta_lower = delta_hat - z * delta_se
                 delta_upper = delta_hat + z * delta_se
 
             # Transform delta -> population-scaled uplift.
             uplift_point = delta_hat * scale
-            uplift_lower = delta_lower * scale
-            uplift_upper = delta_upper * scale
-            # Average half-width divided by z gives an SE-equivalent for an
-            # asymmetric interval; reduces to the exact Wald SE in the Wald
-            # branch.
-            se_uplift = (uplift_upper - uplift_lower) / (2.0 * z) if z > 0 else 0.0
+            if self.analytic_type == "wald_rd":
+                # Random-design delta-method variance: accounts for random antecedent prevalence q_u = n_u / N.
+                var_uplift = (scale ** 2) * var_delta + (delta_hat ** 2) * (scale * (1.0 - scale) / n_total)
+                se_uplift = sqrt(var_uplift)
+                uplift_lower = uplift_point - z * se_uplift
+                uplift_upper = uplift_point + z * se_uplift
+            else:
+                uplift_lower = delta_lower * scale
+                uplift_upper = delta_upper * scale
+                # Average half-width divided by z gives an SE-equivalent for an
+                # asymmetric interval; reduces to the exact Wald SE in the Wald
+                # branch.
+                se_uplift = (uplift_upper - uplift_lower) / (2.0 * z) if z > 0 else 0.0
 
             support = n_u_ante
             confidence = p_u

{action_rules-2.0.1 → action_rules-2.1.0}/src/action_rules/inference/base.py

@@ -7,6 +7,7 @@ functions consumed by all CI engines (analytic, bootstrap, Bayesian).
 from abc import ABC, abstractmethod
 from dataclasses import dataclass, field
 from enum import Enum
+import math
 from typing import TYPE_CHECKING, Dict, List, Optional, Tuple
 
 import numpy as np
@@ -32,11 +33,14 @@ class RuleCategory(Enum):
         The entire CI is below the threshold — rule should be discarded.
     UNCERTAIN : str
         The CI straddles the threshold — insufficient evidence to decide.
+    UNSUPPORTED : str
+        Zero antecedent support or undefined CI bounds (NaN).
     """
 
     ACCEPT = 'accept'
     REJECT = 'reject'
     UNCERTAIN = 'uncertain'
+    UNSUPPORTED = 'unsupported'
 
 
 # ---------------------------------------------------------------------------
@@ -147,6 +151,27 @@ class ConfidenceIntervalResult:
     samples_uplift: Optional[np.ndarray] = field(default=None, repr=False)
     samples_gain: Optional[np.ndarray] = field(default=None, repr=False)
 
+    @property
+    def decision_status(self) -> str:
+        """Return a four-way decision status string.
+
+        Returns
+        -------
+        str
+            One of ``'accept'``, ``'reject'``, ``'uncertain'``, or
+            ``'unsupported'`` (when ``support == 0`` or CI bounds are ``NaN``).
+        """
+        if (
+            self.support == 0
+            or math.isnan(self.uplift_ci_lower)
+            or math.isnan(self.uplift_ci_upper)
+            or self.category == RuleCategory.UNSUPPORTED
+        ):
+            return RuleCategory.UNSUPPORTED.value
+        if self.category is not None:
+            return self.category.value
+        return RuleCategory.UNCERTAIN.value
+
     def to_dict(self, include_samples: bool = False) -> dict:
         """Return a plain dict representation of this result.
 
@@ -601,10 +626,13 @@ def categorize_rule(ci_lower: float, ci_upper: float, threshold: float) -> RuleC
     Returns
     -------
     RuleCategory
+        - :attr:`RuleCategory.UNSUPPORTED` when either CI bound is ``NaN``
         - :attr:`RuleCategory.ACCEPT` when ``ci_lower >= threshold``
         - :attr:`RuleCategory.REJECT` when ``ci_upper < threshold``
         - :attr:`RuleCategory.UNCERTAIN` otherwise
     """
+    if math.isnan(ci_lower) or math.isnan(ci_upper):
+        return RuleCategory.UNSUPPORTED
     if ci_lower >= threshold:
         return RuleCategory.ACCEPT
     if ci_upper < threshold:

{action_rules-2.0.1 → action_rules-2.1.0}/src/action_rules/inference/bayesian.py

@@ -74,11 +74,26 @@ class BayesianEngine(InferenceEngine):
         prior_alpha: float = 1.0,
         prior_beta: float = 1.0,
         random_state: Optional[int] = None,
+        *,
+        prior: Optional[str] = None,
     ):
+        if prior is not None:
+            prior_norm = prior.lower()
+            if prior_norm in ("uniform", "laplace"):
+                prior_alpha, prior_beta = 1.0, 1.0
+            elif prior_norm == "jeffreys":
+                prior_alpha, prior_beta = 0.5, 0.5
+            elif prior_norm == "haldane":
+                prior_alpha, prior_beta = 0.01, 0.01
+            else:
+                raise ValueError(
+                    f"Unknown prior '{prior}'. Choose from {{'uniform', 'laplace', 'jeffreys', 'haldane'}}."
+                )
         self.n_mc = n_mc
         self.prior_alpha = prior_alpha
         self.prior_beta = prior_beta
         self.random_state = random_state
+        self.prior = prior
 
     # ------------------------------------------------------------------
     # Public API

{action_rules-2.0.1 → action_rules-2.1.0}/src/action_rules/inference/bootstrap.py

@@ -134,13 +134,18 @@ class BootstrapEngine(InferenceEngine):
         random_state: Optional[int] = None,
         *,
         bootstrap_type: str = "percentile",
+        resample_mode: str = "rows",
     ):
         valid = {"percentile", "bca"}
         if bootstrap_type not in valid:
             raise ValueError(f"Unknown bootstrap_type '{bootstrap_type}'. Choose from {valid}.")
+        valid_modes = {"rows", "multinomial"}
+        if resample_mode not in valid_modes:
+            raise ValueError(f"Unknown resample_mode '{resample_mode}'. Choose from {valid_modes}.")
         self.n_bootstrap = n_bootstrap
         self.random_state = random_state
         self.bootstrap_type = bootstrap_type
+        self.resample_mode = resample_mode
 
     # ------------------------------------------------------------------
     # Static helpers
@@ -433,41 +438,81 @@ class BootstrapEngine(InferenceEngine):
                 gain_samples[:] = np.nan
 
             n_undefined = 0
-            for b in range(self.n_bootstrap):
-                # Draw a bootstrap resample (with replacement) using integer
-                # index sampling, which is compatible with default_rng.
-                indices = rng.integers(0, n, size=n)
-
-                # Fancy-index the pre-computed boolean masks instead of
-                # slicing the DataFrame — avoids Python-level iteration and
-                # repeated string comparisons.
-                n_u_ante = int(u_ante[indices].sum())
-                n_u_match = int(u_match[indices].sum())
-                n_d_ante = int(d_ante[indices].sum())
-                n_d_match = int(d_match[indices].sum())
-                n_total = n
-
-                # Skip resamples where antecedent support is zero — uplift is
-                # undefined for these draws.  Track the fraction so the caller
-                # can diagnose unstable percentile intervals on low-support rules.
-                if n_u_ante == 0 or n_d_ante == 0:
-                    n_undefined += 1
-                    continue
-
-                uplift_samples[b] = compute_uplift_from_counts(n_u_ante, n_u_match, n_d_ante, n_d_match, n_total)
-
-                if gain_samples is not None and column_values is not None:
-                    conf_u = n_u_match / n_u_ante
-                    conf_d = n_d_match / n_d_ante
-                    gain_samples[b] = compute_realistic_gain(
-                        rule,
-                        conf_u,
-                        conf_d,
-                        intrinsic_utility_table,
-                        transition_utility_table,
-                        column_values,
+            if self.resample_mode == "multinomial" and n > 0:
+                c_u_match = int(u_match.sum())
+                c_u_nonmatch = max(int(u_ante.sum()) - c_u_match, 0)
+                c_d_match = int(d_match.sum())
+                c_d_nonmatch = max(int(d_ante.sum()) - c_d_match, 0)
+                c_other = max(n - (c_u_match + c_u_nonmatch + c_d_match + c_d_nonmatch), 0)
+                probs = np.array(
+                    [c_u_match, c_u_nonmatch, c_d_match, c_d_nonmatch, c_other],
+                    dtype=float,
+                )
+                total_p = probs.sum()
+                if total_p > 0:
+                    probs /= total_p
+                    draws = rng.multinomial(n, probs, size=self.n_bootstrap)
+                    nu_arr = draws[:, 0] + draws[:, 1]
+                    num_arr = draws[:, 0]
+                    nd_arr = draws[:, 2] + draws[:, 3]
+                    ndm_arr = draws[:, 2]
+                    valid_mask = (nu_arr > 0) & (nd_arr > 0)
+                    n_undefined = int((~valid_mask).sum())
+                    if np.any(valid_mask):
+                        conf_u_arr = num_arr[valid_mask] / nu_arr[valid_mask]
+                        conf_d_arr = ndm_arr[valid_mask] / nd_arr[valid_mask]
+                        d_arr = conf_d_arr + conf_u_arr - 1.0
+                        uplift_samples[valid_mask] = d_arr * (nu_arr[valid_mask] / float(n))
+                        if gain_samples is not None and column_values is not None:
+                            for idx_b in np.where(valid_mask)[0]:
+                                gain_samples[idx_b] = compute_realistic_gain(
+                                    rule,
+                                    float(num_arr[idx_b] / nu_arr[idx_b]),
+                                    float(ndm_arr[idx_b] / nd_arr[idx_b]),
+                                    intrinsic_utility_table,
+                                    transition_utility_table,
+                                    column_values,
+                                )
+                else:
+                    n_undefined = self.n_bootstrap
+            else:
+                for b in range(self.n_bootstrap):
+                    # Draw a bootstrap resample (with replacement) using integer
+                    # index sampling, which is compatible with default_rng.
+                    indices = rng.integers(0, n, size=n)
+
+                    # Fancy-index the pre-computed boolean masks instead of
+                    # slicing the DataFrame — avoids Python-level iteration and
+                    # repeated string comparisons.
+                    n_u_ante = int(u_ante[indices].sum())
+                    n_u_match = int(u_match[indices].sum())
+                    n_d_ante = int(d_ante[indices].sum())
+                    n_d_match = int(d_match[indices].sum())
+                    n_total = n
+
+                    # Skip resamples where antecedent support is zero — uplift is
+                    # undefined for these draws.  Track the fraction so the caller
+                    # can diagnose unstable percentile intervals on low-support rules.
+                    if n_u_ante == 0 or n_d_ante == 0:
+                        n_undefined += 1
+                        continue
+
+                    uplift_samples[b] = compute_uplift_from_counts(
+                        n_u_ante, n_u_match, n_d_ante, n_d_match, n_total
                     )
 
+                    if gain_samples is not None and column_values is not None:
+                        conf_u = n_u_match / n_u_ante
+                        conf_d = n_d_match / n_d_ante
+                        gain_samples[b] = compute_realistic_gain(
+                            rule,
+                            conf_u,
+                            conf_d,
+                            intrinsic_utility_table,
+                            transition_utility_table,
+                            column_values,
+                        )
+
             # Compute full-dataset counts from pre-computed masks.
             # These are needed by both percentile and BCa branches.
             n_u_ante_full = int(u_ante.sum())

{action_rules-2.0.1 → action_rules-2.1.0}/src/action_rules/rules/rules.py

@@ -183,6 +183,13 @@ class Rules:
         for attribute_prefix, rules in self.classification_rules.items():
             for desired_rule in rules['desired']:
                 for undesired_rule in rules['undesired']:
+                    # Skip degenerate self-transitions when a real flexible prefix is present
+                    if (
+                        len(attribute_prefix) > 0
+                        and undesired_rule.get('itemset') is not None
+                        and undesired_rule.get('itemset') == desired_rule.get('itemset')
+                    ):
+                        continue
                     # Uplift
                     uplift = self.calculate_uplift(
                         undesired_rule['support'],
@@ -299,6 +306,8 @@ class Rules:
         Uplift measures the increase in the probability of achieving the desired state when applying the action rule
         compared to not applying it. It is used to assess the effectiveness of the rule.
         """
+        if undesired_confidence == 0 or self.count_transactions == 0:
+            return 0.0
         return (
             (desired_confidence - (1 - undesired_confidence)) * (undesired_support / undesired_confidence)
         ) / self.count_transactions

{action_rules-2.0.1 → action_rules-2.1.0}/tests/inference/test_analytic.py

@@ -821,3 +821,39 @@ class TestAutoMode:
 
         assert auto.uplift_point == pytest.approx(wald.uplift_point, rel=1e-12)
         assert auto.uplift_se == pytest.approx(wald.uplift_se, rel=1e-12)
+
+
+class TestRandomDesignAndClopperPearson:
+    """Tests for v2.1.0 random-design Wald ('wald_rd'), 'clopper_pearson', and 'simultaneous_m'."""
+
+    def test_wald_rd_wider_than_fixed_wald(self):
+        """Random-design Wald propagates prevalence uncertainty and is at least as wide as fixed Wald."""
+        data = _make_data(n=200)
+        extra = pd.DataFrame({'age': ['0'] * 10, 'class': ['0'] * 10, 'target': ['1'] * 10})
+        mixed = pd.concat([data, extra], ignore_index=True)
+
+        w_fixed = AnalyticEngine(analytic_type="wald").compute(mixed, [_make_rule()])[0]
+        w_rd = AnalyticEngine(analytic_type="wald_rd").compute(mixed, [_make_rule()])[0]
+        assert w_rd.uplift_point == pytest.approx(w_fixed.uplift_point, rel=1e-12)
+        assert w_rd.uplift_se >= w_fixed.uplift_se
+
+    def test_clopper_pearson_conservative(self):
+        """Clopper-Pearson combined via Newcombe produces valid conservative bounds."""
+        data = _make_data(n=100)
+        extra = pd.DataFrame({'age': ['0'] * 5, 'class': ['0'] * 5, 'target': ['1'] * 5})
+        mixed = pd.concat([data, extra], ignore_index=True)
+
+        cp = AnalyticEngine(analytic_type="clopper_pearson").compute(mixed, [_make_rule()])[0]
+        nw = AnalyticEngine(analytic_type="newcombe_wilson").compute(mixed, [_make_rule()])[0]
+        assert cp.uplift_point == pytest.approx(nw.uplift_point, rel=1e-12)
+        assert (cp.uplift_ci_upper - cp.uplift_ci_lower) >= (nw.uplift_ci_upper - nw.uplift_ci_lower)
+
+    def test_simultaneous_m_widens_interval(self):
+        """Bonferroni multiplicity simultaneous_m > 1 widens the confidence interval."""
+        data = _make_data(n=200)
+        extra = pd.DataFrame({'age': ['0'] * 10, 'class': ['0'] * 10, 'target': ['1'] * 10})
+        mixed = pd.concat([data, extra], ignore_index=True)
+
+        r1 = AnalyticEngine(analytic_type="newcombe_wilson", simultaneous_m=1).compute(mixed, [_make_rule()])[0]
+        r10 = AnalyticEngine(analytic_type="newcombe_wilson", simultaneous_m=10).compute(mixed, [_make_rule()])[0]
+        assert (r10.uplift_ci_upper - r10.uplift_ci_lower) > (r1.uplift_ci_upper - r1.uplift_ci_lower)

{action_rules-2.0.1 → action_rules-2.1.0}/tests/inference/test_base.py

@@ -171,3 +171,16 @@ class TestCategorizeRule:
         """Verify a CI lower bound equal to the threshold yields ACCEPT."""
         # Boundary case: ci_lower exactly at threshold counts as ACCEPT.
         assert categorize_rule(0.0, 0.2, threshold=0.0) is RuleCategory.ACCEPT
+
+    def test_unsupported_when_bounds_nan(self):
+        """Verify NaN CI bounds yield RuleCategory.UNSUPPORTED."""
+        assert categorize_rule(float('nan'), float('nan'), threshold=0.0) is RuleCategory.UNSUPPORTED
+        assert categorize_rule(float('nan'), 0.2, threshold=0.0) is RuleCategory.UNSUPPORTED
+
+    def test_decision_status_property(self):
+        """Verify ConfidenceIntervalResult.decision_status returns 4-way status."""
+        r_acc = _make_result(0, category=RuleCategory.ACCEPT)
+        assert r_acc.decision_status == 'accept'
+        r_unsup = _make_result(1, category=None)
+        r_unsup.support = 0
+        assert r_unsup.decision_status == 'unsupported'

{action_rules-2.0.1 → action_rules-2.1.0}/tests/inference/test_bayesian.py

@@ -451,3 +451,14 @@ class TestMultipleRules:
         result = BayesianEngine(n_mc=5000, random_state=0).compute(data, [_make_rule()])[0]
         # The synthetic data gives perfect uplift; the posterior CI should be fully > 0.
         assert result.category == RuleCategory.ACCEPT
+
+    def test_named_priors_jeffreys_and_uniform(self):
+        """Named priors 'jeffreys', 'uniform', and 'haldane' set the expected Beta hyperparameters."""
+        eng_j = BayesianEngine(n_mc=100, random_state=0, prior="jeffreys")
+        assert eng_j.prior_alpha == 0.5 and eng_j.prior_beta == 0.5
+        eng_u = BayesianEngine(n_mc=100, random_state=0, prior="uniform")
+        assert eng_u.prior_alpha == 1.0 and eng_u.prior_beta == 1.0
+        eng_h = BayesianEngine(n_mc=100, random_state=0, prior="haldane")
+        assert eng_h.prior_alpha == 0.01 and eng_h.prior_beta == 0.01
+        with pytest.raises(ValueError, match="Unknown prior"):
+            BayesianEngine(prior="invalid_prior")

{action_rules-2.0.1 → action_rules-2.1.0}/tests/inference/test_bootstrap.py

@@ -643,3 +643,16 @@ class TestDegenerateResampleReporting:
         # miss them entirely.
         assert result.undefined_bootstrap_fraction is not None
         assert result.undefined_bootstrap_fraction > 0.01
+
+    def test_multinomial_resample_mode_matches_rows_distribution(self):
+        """Vectorised 5-cell multinomial resampling agrees closely with row resampling."""
+        data = _make_data(n=400)
+        r_rows = BootstrapEngine(n_bootstrap=500, random_state=42, resample_mode="rows").compute(
+            data, [_make_rule()]
+        )[0]
+        r_mult = BootstrapEngine(n_bootstrap=500, random_state=42, resample_mode="multinomial").compute(
+            data, [_make_rule()]
+        )[0]
+        assert r_mult.uplift_point == pytest.approx(r_rows.uplift_point, abs=0.03)
+        assert r_mult.uplift_ci_lower == pytest.approx(r_rows.uplift_ci_lower, abs=0.05)
+        assert r_mult.uplift_ci_upper == pytest.approx(r_rows.uplift_ci_upper, abs=0.05)

{action_rules-2.0.1 → action_rules-2.1.0}/tests/rules/test_rules.py

@@ -167,3 +167,24 @@ def test_compute_rule_utility(rules):
     assert abs(result[0] - expected[0]) < tol, f"max_rule_gain: expected {expected[0]}, got {result[0]}"
     assert abs(result[1] - expected[1]) < tol, f"realistic_rule_gain: expected {expected[1]}, got {result[1]}"
     assert abs(result[2] - expected[2]) < tol, f"realistic_rule_gain_dataset: expected {expected[2]}, got {result[2]}"
+
+
+def test_calculate_uplift_zero_confidence_and_zero_transactions(rules):
+    """calculate_uplift returns 0.0 instead of raising ZeroDivisionError when confidence or transactions are 0."""
+    assert rules.calculate_uplift(0, 0.0, 0.8) == 0.0
+    rules.count_transactions = 0
+    assert rules.calculate_uplift(10, 0.5, 0.8) == 0.0
+
+
+def test_generate_action_rules_skips_identical_itemsets_with_prefix(rules):
+    """generate_action_rules skips self-paired identical itemsets when attribute_prefix is non-empty."""
+    rules.add_classification_rules(
+        ('flex_attr',),
+        (0,),
+        [{'item': 1, 'support': 10, 'confidence': 0.4}, {'item': 2, 'support': 12, 'confidence': 0.7}],
+        [{'item': 1, 'support': 15, 'confidence': 0.6}],
+    )
+    rules.generate_action_rules()
+    assert len(rules.action_rules) == 1
+    assert rules.action_rules[0]['undesired']['itemset'] == (0, 2)
+    assert rules.action_rules[0]['desired']['itemset'] == (0, 1)

{action_rules-2.0.1 → action_rules-2.1.0}/tests/test_confidence_intervals.py

@@ -1150,3 +1150,23 @@ class TestCLI:
         finally:
             os.unlink(csv_path)
             os.unlink(json_path)
+
+
+class TestV210Extensions:
+    """Integration tests for v2.1.0 confidence_intervals methods and options."""
+
+    def test_wald_rd_and_clopper_pearson_and_jeffreys_and_honest_split(self, fitted_ar):
+        """Verify new method aliases ('wald_rd', 'clopper_pearson', 'jeffreys', 'honest_split') run cleanly."""
+        ar, data = fitted_ar
+        res_rd = ar.confidence_intervals(data, method="wald_rd")
+        assert len(res_rd) == len(ar.output.action_rules)
+        res_cp = ar.confidence_intervals(data, method="clopper_pearson", simultaneous_m=len(res_rd))
+        assert len(res_cp) == len(ar.output.action_rules)
+        res_j = ar.confidence_intervals(data, method="jeffreys", n_mc=200, random_state=42)
+        assert len(res_j) == len(ar.output.action_rules)
+        res_hs = ar.confidence_intervals(data, method="honest_split", discovery_fraction=0.5, random_state=42)
+        assert len(res_hs) == len(ar.output.action_rules)
+        res_mult = ar.confidence_intervals(
+            data, method="bootstrap", n_bootstrap=50, random_state=42, resample_mode="multinomial"
+        )
+        assert len(res_mult) == len(ar.output.action_rules)