mergeron 2024.738949.1__py3-none-any.whl → 2024.738949.6__py3-none-any.whl

mergeron/core/guidelines_boundaries_specialized_functions.py

@@ -0,0 +1,341 @@
+"""
+Specialized routines for defining and analyzing boundaries for Guidelines standards.
+
+These routines provide improved precision or demonstrate additional methods, but tend
+to have poor performance
+
+"""
+
+from importlib.metadata import version
+from typing import Literal
+
+import numpy as np
+from mpmath import mp, mpf  # type: ignore
+from scipy.spatial.distance import minkowski as distance_function  # type: ignore
+from sympy import lambdify, simplify, solve, symbols
+
+from .. import _PKG_NAME  # noqa: TID252
+from .guidelines_boundaries import (
+    GuidelinesBoundary,
+    GuidelinesBoundaryCallable,
+    _shrratio_boundary_intcpt,
+    lerp,
+)
+
+__version__ = version(_PKG_NAME)
+
+
+mp.prec = 80
+mp.trap_complex = True
+
+
+def delta_hhi_boundary_qdtr(_dh_val: float = 0.01) -> GuidelinesBoundaryCallable:
+    """
+    Generate the list of share combination on the ΔHHI boundary.
+
+    Parameters
+    ----------
+    _dh_val:
+        Merging-firms' ΔHHI bound.
+    prec
+        Number of decimal places for rounding reported shares.
+
+    Returns
+    -------
+        Callable to generate array of share-pairs, area under boundary.
+
+    """
+
+    _dh_val = mpf(f"{_dh_val}")
+
+    _s_1, _s_2 = symbols("s_1, s_2", positive=True)
+
+    _hhi_eqn = _s_2 - 0.01 / (2 * _s_1)
+
+    _hhi_bdry = solve(_hhi_eqn, _s_2)[0]  # type: ignore
+    _s_nought = float(solve(_hhi_eqn.subs({_s_2: 1 - _s_1}), _s_1)[0])  # type: ignore
+
+    _hhi_bdry_area = 2 * (
+        _s_nought
+        + mp.quad(lambdify(_s_1, _hhi_bdry, "mpmath"), (_s_nought, 1 - _s_nought))
+    )
+
+    return GuidelinesBoundaryCallable(
+        lambdify(_s_1, _hhi_bdry, "numpy"), _hhi_bdry_area, _s_nought
+    )
+
+
+def shrratio_boundary_qdtr_wtd_avg(
+    _delta_star: float = 0.075,
+    _r_val: float = 0.80,
+    /,
+    *,
+    weighting: Literal["own-share", "cross-product-share"] | None = "own-share",
+    recapture_spec: Literal["inside-out", "proportional"] = "inside-out",
+) -> GuidelinesBoundaryCallable:
+    """
+    Share combinations for the share-weighted average GUPPI boundary with symmetric
+    merging-firm margins.
+
+    Parameters
+    ----------
+    _delta_star
+        corollary to GUPPI bound (:math:`\\overline{g} / (m^* \\cdot \\overline{r})`)
+    _r_val
+        recapture ratio
+    weighting
+        Whether "own-share" or "cross-product-share" (or None for simple, unweighted average)
+    recapture_spec
+        Whether recapture-ratio is MNL-consistent ("inside-out") or has fixed
+        value for both merging firms ("proportional").
+
+    Returns
+    -------
+        Array of share-pairs, area under boundary.
+
+    """
+
+    _delta_star = mpf(f"{_delta_star}")
+    _s_mid = _delta_star / (1 + _delta_star)
+    _s_naught = 0
+
+    _s_1, _s_2 = symbols("s_1:3", positive=True)
+
+    match weighting:
+        case "own-share":
+            _bdry_eqn = (
+                _s_1 * _s_2 / (1 - _s_1)
+                + _s_2
+                * _s_1
+                / (
+                    (1 - (_r_val * _s_2 + (1 - _r_val) * _s_1))
+                    if recapture_spec == "inside-out"
+                    else (1 - _s_2)
+                )
+                - (_s_1 + _s_2) * _delta_star
+            )
+
+            _bdry_func = solve(_bdry_eqn, _s_2)[0]  # type: ignore
+            _s_naught = (
+                float(solve(simplify(_bdry_eqn.subs({_s_2: 1 - _s_1})), _s_1)[0])  # type: ignore
+                if recapture_spec == "inside-out"
+                else 0
+            )
+            _bdry_area = float(
+                2
+                * (
+                    _s_naught
+                    + mp.quad(lambdify(_s_1, _bdry_func, "mpmath"), (_s_naught, _s_mid))
+                )
+                - (_s_mid**2 + _s_naught**2)
+            )
+
+        case "cross-product-share":
+            mp.trap_complex = False
+            _d_star = symbols("d", positive=True)
+            _bdry_eqn = (
+                _s_2 * _s_2 / (1 - _s_1)
+                + _s_1
+                * _s_1
+                / (
+                    (1 - (_r_val * _s_2 + (1 - _r_val) * _s_1))
+                    if recapture_spec == "inside-out"
+                    else (1 - _s_2)
+                )
+                - (_s_1 + _s_2) * _d_star
+            )
+
+            _bdry_func = solve(_bdry_eqn, _s_2)[1]  # type: ignore
+            _bdry_area = float(
+                2
+                * (
+                    mp.quad(
+                        lambdify(
+                            _s_1, _bdry_func.subs({_d_star: _delta_star}), "mpmath"
+                        ),
+                        (0, _s_mid),
+                    )
+                ).real
+                - _s_mid**2
+            )
+
+        case _:
+            _bdry_eqn = (
+                1 / 2 * _s_2 / (1 - _s_1)
+                + 1
+                / 2
+                * _s_1
+                / (
+                    (1 - (_r_val * _s_2 + (1 - _r_val) * _s_1))
+                    if recapture_spec == "inside-out"
+                    else (1 - _s_2)
+                )
+                - _delta_star
+            )
+
+            _bdry_func = solve(_bdry_eqn, _s_2)[0]  # type: ignore
+            _bdry_area = float(
+                2 * (mp.quad(lambdify(_s_1, _bdry_func, "mpmath"), (0, _s_mid)))
+                - _s_mid**2
+            )
+
+    return GuidelinesBoundaryCallable(
+        lambdify(_s_1, _bdry_func, "numpy"), _bdry_area, _s_naught
+    )
+
+
+def shrratio_boundary_distance(
+    _delta_star: float = 0.075,
+    _r_val: float = 0.80,
+    /,
+    *,
+    agg_method: Literal["arithmetic", "distance"] = "arithmetic",
+    weighting: Literal["own-share", "cross-product-share"] | None = "own-share",
+    recapture_spec: Literal["inside-out", "proportional"] = "inside-out",
+    prec: int = 5,
+) -> GuidelinesBoundary:
+    """
+    Share combinations for the GUPPI boundaries using various aggregators with
+    symmetric merging-firm margins.
+
+    Reimplements the arithmetic-averages and distance estimations from function,
+    `shrratio_boundary_wtd_avg`but uses the Minkowski-distance function,
+    `scipy.spatial.distance.minkowski` for all aggregators. This reimplementation
+    is useful for testing the output of `shrratio_boundary_wtd_avg`
+    but runs considerably slower.
+
+    Parameters
+    ----------
+    _delta_star
+        corollary to GUPPI bound (:math:`\\overline{g} / (m^* \\cdot \\overline{r})`)
+    _r_val
+        recapture ratio
+    agg_method
+        Whether "arithmetic", "geometric", or "distance".
+    weighting
+        Whether "own-share" or "cross-product-share".
+    recapture_spec
+        Whether recapture-ratio is MNL-consistent ("inside-out") or has fixed
+        value for both merging firms ("proportional").
+    prec
+        Number of decimal places for rounding returned shares and area.
+
+    Returns
+    -------
+        Array of share-pairs, area under boundary.
+
+    """
+
+    _delta_star = mpf(f"{_delta_star}")
+    _s_mid = _delta_star / (1 + _delta_star)
+
+    # initial conditions
+    _gbdry_points = [(_s_mid, _s_mid)]
+    _s_1_pre, _s_2_pre = _s_mid, _s_mid
+    _s_2_oddval, _s_2_oddsum, _s_2_evnsum = True, 0, 0
+
+    # parameters for iteration
+    _weights_base = (mpf("0.5"),) * 2
+    _gbd_step_sz = mp.power(10, -prec)
+    _theta = _gbd_step_sz * (10 if weighting == "cross-product-share" else 1)
+    for _s_1 in mp.arange(_s_mid - _gbd_step_sz, 0, -_gbd_step_sz):
+        # The wtd. avg. GUPPI is not always convex to the origin, so we
+        #   increment _s_2 after each iteration in which our algorithm
+        #   finds (s1, s2) on the boundary
+        _s_2 = _s_2_pre * (1 + _theta)
+
+        if (_s_1 + _s_2) > mpf("0.99875"):
+            # 1: # We lose accuracy at 3-9s and up
+            break
+
+        while True:
+            _de_1 = _s_2 / (1 - _s_1)
+            _de_2 = (
+                _s_1 / (1 - lerp(_s_1, _s_2, _r_val))
+                if recapture_spec == "inside-out"
+                else _s_1 / (1 - _s_2)
+            )
+
+            _weights_i = (
+                (
+                    _w1 := mp.fdiv(
+                        _s_2 if weighting == "cross-product-share" else _s_1,
+                        _s_1 + _s_2,
+                    ),
+                    1 - _w1,
+                )
+                if weighting
+                else _weights_base
+            )
+
+            match agg_method:
+                case "arithmetic":
+                    _delta_test = distance_function(
+                        (_de_1, _de_2), (0.0, 0.0), p=1, w=_weights_i
+                    )
+                case "distance":
+                    _delta_test = distance_function(
+                        (_de_1, _de_2), (0.0, 0.0), p=2, w=_weights_i
+                    )
+
+            _test_flag, _incr_decr = (
+                (_delta_test > _delta_star, -1)
+                if weighting == "cross-product-share"
+                else (_delta_test < _delta_star, 1)
+            )
+
+            if _test_flag:
+                _s_2 += _incr_decr * _gbd_step_sz
+            else:
+                break
+
+        # Build-up boundary points
+        _gbdry_points.append((_s_1, _s_2))
+
+        # Build up area terms
+        _s_2_oddsum += _s_2 if _s_2_oddval else 0
+        _s_2_evnsum += _s_2 if not _s_2_oddval else 0
+        _s_2_oddval = not _s_2_oddval
+
+        # Hold share points
+        _s_2_pre = _s_2
+        _s_1_pre = _s_1
+
+    if _s_2_oddval:
+        _s_2_evnsum -= _s_2_pre
+    else:
+        _s_2_oddsum -= _s_1_pre
+
+    _s_intcpt = _shrratio_boundary_intcpt(
+        _s_1_pre,
+        _delta_star,
+        _r_val,
+        recapture_spec=recapture_spec,
+        agg_method=agg_method,
+        weighting=weighting,
+    )
+
+    if weighting == "own-share":
+        _gbd_prtlarea = (
+            _gbd_step_sz * (4 * _s_2_oddsum + 2 * _s_2_evnsum + _s_mid + _s_2_pre) / 3
+        )
+        # Area under boundary
+        _gbdry_area_total = 2 * (_s_1_pre + _gbd_prtlarea) - (
+            mp.power(_s_mid, "2") + mp.power(_s_1_pre, "2")
+        )
+
+    else:
+        _gbd_prtlarea = (
+            _gbd_step_sz * (4 * _s_2_oddsum + 2 * _s_2_evnsum + _s_mid + _s_intcpt) / 3
+        )
+        # Area under boundary
+        _gbdry_area_total = 2 * _gbd_prtlarea - mp.power(_s_mid, "2")
+
+    _gbdry_points = np.row_stack((_gbdry_points, (mpf("0.0"), _s_intcpt))).astype(
+        np.float64
+    )
+    # Points defining boundary to point-of-symmetry
+    return GuidelinesBoundary(
+        np.row_stack((np.flip(_gbdry_points, 0), np.flip(_gbdry_points[1:], 1))),
+        round(float(_gbdry_area_total), prec),
+    )

mergeron/core/pseudorandom_numbers.py

@@ -145,7 +145,7 @@ class MultithreadedRNG:
         dist_type: Literal[
             "Beta", "Dirichlet", "Gaussian", "Normal", "Random", "Uniform"
         ] = "Uniform",
-        dist_parms: NDArray[np.floating[TF]] | None = DIST_PARMS_DEFAULT,
+        dist_parms: NDArray[np.floating[TF]] | None = DIST_PARMS_DEFAULT,  # type: ignore
         seed_sequence: SeedSequence | None = None,
         nthreads: int = NTHREADS,
     ):

mergeron/examples/concentration_as_diversion.py

@@ -27,18 +27,21 @@ from pathlib import Path
 from typing import Any, Literal
 
 import matplotlib.axes as mpa
-from joblib import Parallel, cpu_count, delayed
+from jinja2 import FileSystemLoader
+from joblib import Parallel, cpu_count, delayed  # type: ignore
 from numpy import pi
-from xlsxwriter import Workbook
+from xlsxwriter import Workbook  # type: ignore
 
 import mergeron.core.excel_helper as xlh
 import mergeron.core.guidelines_boundaries as gbl
 import mergeron.ext.tol_colors as ptcolor
-from mergeron import DATA_DIR
+import mergeron.gen.investigations_stats as isl
+from mergeron import DATA_DIR, RECConstants, UPPAggrSelector
+from mergeron.core import UPPBoundarySpec
 
 PROG_PATH = Path(__file__)
 
-RECAPTURE_SPEC = "inside-out"
+RECAPTURE_SPEC = RECConstants.INOUT
 # Map boundary forms to titles and generating-function names, with
 #   additional parameters as relevant
 BDRY_SPECS_DICT: Mapping[str, Mapping[str, Any]] = {
@@ -52,26 +55,22 @@ BDRY_SPECS_DICT: Mapping[str, Mapping[str, Any]] = {
         "title_str": "Aggregated-diversion-ratio boundary, own-share wtd. avg.",
         "sheet_name": "OSWAG, wtd avg",
         "func_str": R"(s_1 d_{12} + s_2 d_{21}) / s_M",
-        "func": gbl.shrratio_boundary_wtd_avg,
-        "func_kwargs": {"wgtng_policy": "own-share", "recapture_spec": RECAPTURE_SPEC},
+        "agg_method": UPPAggrSelector.OSA,
+        "recapture_spec": RECAPTURE_SPEC,
     },
     "OSWAG Own-shr-wtd Div Ratio Distance": {
         "title_str": "Aggregated-diversion-ratio boundary, own-shr. wtd. distance",
         "sheet_name": "OSWAG, distance",
         "func_str": R"\surd (s_1 d_{12}^2 / s_M + s_2 d_{21}^2 / s_M)",
-        "func": gbl.shrratio_boundary_wtd_avg,
-        "func_kwargs": {
-            "wgtng_policy": "own-share",
-            "recapture_spec": RECAPTURE_SPEC,
-            "avg_method": "distance",
-        },
+        "agg_method": UPPAggrSelector.OSD,
+        "recapture_spec": RECAPTURE_SPEC,
     },
     "OSWAG Min Div Ratio": {
         "title_str": "Aggregated-diversion-ratio boundary, minimum",
         "sheet_name": "OSWAG, minimum",
         "func_str": R"\min (d_{12}, d_{21})",
-        "func": gbl.shrratio_boundary_min,
-        "func_kwargs": {"recapture_spec": RECAPTURE_SPEC},
+        "agg_method": UPPAggrSelector.MIN,
+        "recapture_spec": RECAPTURE_SPEC,
     },
     "SAG Combined Share": {
         "title_str": "Combined Share boundary",
@@ -79,23 +78,19 @@ BDRY_SPECS_DICT: Mapping[str, Mapping[str, Any]] = {
         "func_str": R"s_M",
         "func": gbl.combined_share_boundary,
     },
-    "SAG Div Ratio Distance": {
-        "title_str": "Aggregated-diversion-ratio boundary, distance",
-        "sheet_name": "SAG, distance",
-        "func_str": R"\surd (d_{12}^2 / 2 + d_{21}^2 / 2)",
-        "func": gbl.shrratio_boundary_wtd_avg,
-        "func_kwargs": {
-            "wgtng_policy": None,
-            "recapture_spec": RECAPTURE_SPEC,
-            "avg_method": "distance",
-        },
-    },
     "SAG Average Div Ratio": {
         "title_str": "Aggregated-diversion-ratio boundary, simple average",
         "sheet_name": "SAG, average",
         "func_str": R"(d_{12} + d_{21}) / 2",
-        "func": gbl.shrratio_boundary_xact_avg,
-        "func_kwargs": {"recapture_spec": RECAPTURE_SPEC},
+        "agg_method": UPPAggrSelector.AVG,
+        "recapture_spec": RECAPTURE_SPEC,
+    },
+    "SAG Div Ratio Distance": {
+        "title_str": "Aggregated-diversion-ratio boundary, distance",
+        "sheet_name": "SAG, distance",
+        "func_str": R"\surd (d_{12}^2 / 2 + d_{21}^2 / 2)",
+        "agg_method": UPPAggrSelector.DIS,
+        "recapture_spec": RECAPTURE_SPEC,
     },
     "CPSWAG Premerger HHI-contribution": {
         "title_str": "Premerger HHI-contribution boundary",
@@ -107,33 +102,27 @@ BDRY_SPECS_DICT: Mapping[str, Mapping[str, Any]] = {
         "title_str": "Aggregated-diversion-ratio boundary, cross-product-share wtd. avg.",
         "sheet_name": "CPSWAG, wtd avg",
         "func_str": R"(s_2 d_{12} / s_M  + s_1 d_{21} / s_M)",
-        "func": gbl.shrratio_boundary_wtd_avg,
-        "func_kwargs": {
-            "wgtng_policy": "cross-product-share",
-            "recapture_spec": RECAPTURE_SPEC,
-        },
+        "agg_method": UPPAggrSelector.CPA,
+        "recapture_spec": RECAPTURE_SPEC,
     },
     "CPSWAG Cross-product-shr-wtd Div Ratio Distance": {
         "title_str": "Aggregated-diversion-ratio boundary, cross-prod-shr. wtd. distance",
         "sheet_name": "CPSWAG, distance",
         "func_str": R"\surd (s_2 d_{12}^2 / s_M + s_1 d_{21}^2 / s_M)",
-        "func": gbl.shrratio_boundary_wtd_avg,
-        "func_kwargs": {
-            "wgtng_policy": "cross-product-share",
-            "recapture_spec": RECAPTURE_SPEC,
-            "avg_method": "distance",
-        },
+        "agg_method": UPPAggrSelector.CPD,
+        "recapture_spec": RECAPTURE_SPEC,
     },
     "CPSWAG Max Div Ratio": {
         "title_str": "Aggregated-diversion-ratio boundary, maximum",
         "sheet_name": "CPSWAG, maximum",
         "func_str": R"\max (d_{12}, d_{21})",
-        "func": gbl.shrratio_boundary_max,
+        "agg_method": UPPAggrSelector.MAX,
+        "recapture_spec": RECAPTURE_SPEC,
     },
 }
 
 
-def tabulate_boundary_stats(_gpubyr: Literal[1992, 2010, 2023], /) -> None:
+def tabulate_boundary_stats(_gpubyr: gbl.HMGPubYear, /) -> None:
     """
     Parameters
     ----------
@@ -142,15 +131,17 @@ def tabulate_boundary_stats(_gpubyr: Literal[1992, 2010, 2023], /) -> None:
         are drawn
 
     """
+    _invres_rate_table_content = isl.StatsContainer()
+
     gso = gbl.GuidelinesThresholds(_gpubyr)
     _dhhi_val, _r_val, _g_val = (
         getattr(gso.presumption, _f) for _f in ("delta", "rec", "guppi")
     )
 
     _dhhi_seq = (
-        (0.01, 0.02, 0.03125, 0.05, _dhhi_val)
+        (0.005, 0.01, 0.02, gso.imputed_presumption.delta, 0.08)
         if _gpubyr == 2010
-        else (0.005, 0.01, 0.02, 0.03125, _dhhi_val)
+        else (0.005, 0.01, 0.02, gso.imputed_presumption.delta, 0.08)
     )
 
     _bdry_approx_data_dict = {
@@ -166,7 +157,7 @@ def tabulate_boundary_stats(_gpubyr: Literal[1992, 2010, 2023], /) -> None:
                 ),
             )
             for _k in BDRY_SPECS_DICT
-            if not _k.endswith("Distance")
+            # if not _k.endswith("Distance")
         }
     }
     _bdry_approx_data_dict |= {
@@ -176,32 +167,46 @@ def tabulate_boundary_stats(_gpubyr: Literal[1992, 2010, 2023], /) -> None:
     }
 
     _bdry_data = Parallel(n_jobs=-1)(
-        delayed(_dhhi_stats)(_dhhi_val, _r_val, _g_val) for _dhhi_val in _dhhi_seq
+        delayed(_dhhi_stats)(_dhhi_val, _r_val) for _dhhi_val in _dhhi_seq
     )
     _bdry_approx_data_dict |= dict(_bdry_data)
 
-    print(" & ".join(_k for _k in _bdry_approx_data_dict), R" \\")
+    _data_str = ""
+    _data_str = "{} \\\\ \n".format(
+        " & ".join(
+            _k.replace("Criterion", R"{\text{} \\ Criterion}")  # \phantom{Criterion}
+            for _k in _bdry_approx_data_dict
+        )
+    )
     for _sk in _bdry_approx_data_dict["Criterion"]:
-        print(
-            " & ".join(
-                _bdry_approx_data_dict[_k][_sk] for _k in _bdry_approx_data_dict
-            ),
-            R"\\",
+        _data_str += "{} \\\\ \n".format(
+            " & ".join(_bdry_approx_data_dict[_k][_sk] for _k in _bdry_approx_data_dict)
         )
+    print(_data_str)
+
+    _invres_rate_table_content.data_str = _data_str
+
+    _j2_env = isl.latex_jinja_env
+    _j2_env.loader = FileSystemLoader(str(PROG_PATH.parent / "templates"))
+    _j2_templ = _j2_env.get_template(
+        "concentration_as_diversion_intrinsic_enforcement_rates.tex.jinja2"
+    )
+    PROG_PATH.parents[1].joinpath(
+        f"{PROG_PATH.stem}_intrinsic_enforcement_rates_{_gpubyr}.tex"
+    ).write_text(_j2_templ.render(tmpl_data=_invres_rate_table_content))
 
 
-def _dhhi_stats(
-    _dhhi_val: float, _r_val: float, _g_val: float
-) -> tuple[str, dict[str, str]]:
+def _dhhi_stats(_dhhi_val: float, _r_val: float) -> tuple[str, dict[str, str]]:
     _dhhi_val = round(_dhhi_val, 5)
 
-    _r_val = round(_r_val, 4)
-    _s_mid = sqrt(_dhhi_val / 2)
+    _divr_val = gbl.gbd_from_dsf(_dhhi_val, r_bar=_r_val)
+    _delta_val = gbl.critical_shrratio(_divr_val, r_bar=_r_val)
+    # _s_mid = sqrt(_dhhi_val / 2)
 
-    _delta_val = _s_mid / (1 - _s_mid)
-    if _dhhi_val * 1e4 in (50, 100, 200):
-        _delta_val = gbl.round_cust(_r_val * _delta_val) / _r_val
-    _divr_val = _r_val * _delta_val
+    # _delta_val = _s_mid / (1 - _s_mid)
+    # if _dhhi_val * 1e4 in (50, 100, 200):
+    #     _delta_val = gbl.critical_shrratio()(_r_val * _delta_val) / _r_val
+    # _divr_val = _r_val * _delta_val
 
     print(
         "Processing data for ΔHHI = {0:.{1}f} points;".format(
@@ -237,18 +242,23 @@ def _bdry_stats_col(
         case "CPSWAG Premerger HHI-contribution":
             return _bdry_spec, f"{_hhi_m_pre_prob:6.5f}"
         case _ if "Div Ratio" in _bdry_spec:
-            _gbd_func = BDRY_SPECS_DICT[_bdry_spec]["func"]
-            _, _within_bdry_area = _gbd_func(
-                _delta_val, _r_val, **BDRY_SPECS_DICT[_bdry_spec].get("func_kwargs", {})
-            )
+            _within_bdry_area = gbl.shrratio_boundary(
+                UPPBoundarySpec(
+                    _delta_val,
+                    _r_val,
+                    agg_method=BDRY_SPECS_DICT[_bdry_spec]["agg_method"],
+                    recapture_spec=BDRY_SPECS_DICT[_bdry_spec]["recapture_spec"],
+                )
+            ).area
             _within_bdry_prob = 2 * _within_bdry_area
-            _within_conc_bdry_prob = (
-                _hhi_m_pre_prob
-                if _bdry_spec.startswith("CPSWAG")
-                else (_cs_prob if _bdry_spec.startswith("SAG") else _dhhi_prob)
-            )
-
-            return _bdry_spec, R"{{ {:6.5f} \\ {:.2f}\% }}".format(
+            if _bdry_spec.startswith("CPSWAG"):
+                _within_conc_bdry_prob = _hhi_m_pre_prob
+            elif _bdry_spec.startswith("SAG"):
+                _within_conc_bdry_prob = _cs_prob
+            else:
+                _within_conc_bdry_prob = _dhhi_prob
+
+            return _bdry_spec, R"{{ {:6.5f} \\ {:.2f}\% }}".format(  # noqa: UP032
                 _within_bdry_prob,
                 100 * (1 - (_within_conc_bdry_prob / _within_bdry_prob)),
             )
@@ -257,7 +267,7 @@ def _bdry_stats_col(
 
 
 def plot_and_save_boundary_coords(
-    _gpubyr: Literal[1992, 2010, 2023],
+    _gpubyr: gbl.HMGPubYear,
     _xl_book: Workbook,
     /,
     layout: Literal["collected", "distributed"] = "collected",
@@ -390,10 +400,11 @@ def gen_plot_boundary(
     print(_bdry_spec_dict["title_str"])
 
     _pt_mdco: ptcolor.Mcset = ptcolor.tol_cset("medium-contrast")  # type: ignore
+    _pt_vbco: ptcolor.Vcset = ptcolor.tol_cset("vibrant")  # type: ignore
 
     _plot_line_width = 1.0
     _plot_line_alpha = 0.8
-    _plot_line_color = _pt_mdco.black
+    _plot_line_color = _pt_vbco.black
     _plot_line_style = {"OSWAG": "-", "SAG": "-.", "CPSWAG": "--"}.get(
         _bdry_spec_str.split(" ")[0], "-"
     )
@@ -407,15 +418,14 @@ def gen_plot_boundary(
             case _ if _bdry_spec_str.startswith(("SAG Combined", "CPSWAG Premerger")):
                 _zrdr = 2
             case _ if "Distance" in _bdry_spec_str:
-                _plot_line_color = _pt_mdco.light_blue
+                _plot_line_color = _pt_vbco.blue
                 _zrdr = 3
             case _ if "shr-wtd" in _bdry_spec_str or "Mean" in _bdry_spec_str:
-                _plot_line_color = _pt_mdco.light_yellow
+                _plot_line_color = _pt_vbco.teal
                 _zrdr = 3
             case _:
-                _plot_line_color = _pt_mdco.dark_red
+                _plot_line_color = _pt_vbco.red
 
-    _dh_bar = _gso.safeharbor.divr
     _g_val = _gso.safeharbor.guppi
 
     _r_bar = _gso.presumption.rec
@@ -424,12 +434,15 @@ def gen_plot_boundary(
     _s_mid = sqrt(_dhhi_val / 2)
     _delta_val = _g_val / _r_bar if _gs_str == "safeharbor" else _s_mid / (1 - _s_mid)
 
-    _bdry_func = _bdry_spec_dict["func"]
+    _bdry_func = _bdry_spec_dict.get("func", gbl.shrratio_boundary)
     if "Div Ratio" in _bdry_spec_str:
-        _bdry_boundary = _bdry_func(
-            _delta_val,
-            _r_bar,
-            **_bdry_spec_dict.get("func_kwargs", {}),  # tupe: ignore
+        _bdry_boundary = gbl.shrratio_boundary(
+            UPPBoundarySpec(
+                _delta_val,
+                _r_bar,
+                agg_method=_bdry_spec_dict["agg_method"],
+                recapture_spec=_bdry_spec_dict["recapture_spec"],
+            )
         )
         _plot_label_mag, _plot_label_uom = _r_bar * _delta_val * 1e2, "%"
     elif _bdry_spec_str.endswith("Combined Share"):
@@ -599,8 +612,9 @@ def boundary_data_to_worksheet(
 
 
 if __name__ == "__main__":
-    for gpubyr in [1992, 2010, 2023][2:]:
-        # tabulate_boundary_stats(gpubyr)
+    gpubyrs: list[gbl.HMGPubYear] = [1992, 2010, 2023]
+    for gpubyr in gpubyrs[2:][:1]:
+        tabulate_boundary_stats(gpubyr)
 
         # Initiliaze workbook for saving boundary coordinates
         with Workbook(