mergeron 2024.738936.2__tar.gz → 2024.738940.0__tar.gz

{mergeron-2024.738936.2 → mergeron-2024.738940.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mergeron
-Version: 2024.738936.2
+Version: 2024.738940.0
 Summary: Analysis of standards defined in Horizontal Merger Guidelines
 License: MIT
 Keywords: merger policy analysis,merger guidelines,merger screening,policy presumptions,concentration standards,upward pricing pressure,GUPPI

{mergeron-2024.738936.2 → mergeron-2024.738940.0}/pyproject.toml

@@ -1,7 +1,7 @@
 [tool.poetry]
 name = "mergeron"
 # See ./get_version_str.py
-version = "2024.738936.2"
+version = "2024.738940.0"
 description = "Analysis of standards defined in Horizontal Merger Guidelines"
 keywords = [
     "merger policy analysis",

{mergeron-2024.738936.2 → mergeron-2024.738940.0}/src/mergeron/core/excel_helper.py

@@ -6,6 +6,8 @@ Includes a flexible system of defining cell formats.
 
 """
 
+from __future__ import annotations
+
 from importlib.metadata import version
 
 from .. import _PKG_NAME  # noqa: TID252
@@ -126,7 +128,7 @@ def matrix_to_sheet(
     elif isinstance(cell_format, CFmt):
         _cell_format = (cell_format,) * len(_data_array[0])
     else:
-        _cell_format = (CFmt.XL_DEFAULT,) * len(_data_array[0])
+        _cell_format = (CFmt.XL_DEFAULT,) * len(_data_array[0])  # type: ignore
 
     for _cell_row in range(_row_id, _bottom_row_id):
         for _cell_col in range(_col_id, _right_column_id):
@@ -222,7 +224,7 @@ def xl_fmt(
     elif isinstance(_cell_fmt, CFmt):
         _cell_fmt_dict = _cell_fmt.value
     else:
-        _cell_fmt_dict = CFmt.XL_DEFAULT.value
+        _cell_fmt_dict = CFmt.XL_DEFAULT.value  # type: ignore
 
     return _xl_book.add_format(_cell_fmt_dict)
 

{mergeron-2024.738936.2 → mergeron-2024.738940.0}/src/mergeron/core/guidelines_standards.py

@@ -4,7 +4,6 @@ with a canvas on which to draw boundaries for Guidelines standards.
 
 """
 
-from collections import namedtuple
 from importlib.metadata import version
 
 from .. import _PKG_NAME  # noqa: TID252
@@ -12,9 +11,11 @@ from .. import _PKG_NAME  # noqa: TID252
 __version__ = version(_PKG_NAME)
 
 import decimal
+from dataclasses import dataclass
 from typing import Any, Literal, TypeAlias
 
 import numpy as np
+from attr import define, field
 from mpmath import mp, mpf  # type: ignore
 from numpy.typing import NDArray
 from scipy.spatial.distance import minkowski as distance_function
@@ -23,9 +24,25 @@ mp.prec = 80
 mp.trap_complex = True
 
 HMGPubYear: TypeAlias = Literal[1992, 2010, 2023]
-GuidelinesSTD = namedtuple("GuidelinesSTD", "delta rec guppi divr cmcr ipr")
 
 
+@dataclass(slots=True, frozen=True)
+class GuidelinesBoundary:
+    coordinates: NDArray[np.float64]
+    area: float
+
+
+@define(slots=True, frozen=True)
+class GuidelinesSTD:
+    delta: float
+    rec: float
+    guppi: float
+    divr: float
+    cmcr: float
+    ipr: float
+
+
+@define(slots=True, frozen=True)
 class GuidelinesStandards:
     """
     Guidelines standards by Guidelines publication year
@@ -33,76 +50,100 @@ class GuidelinesStandards:
     Diversion ratio, GUPPI, CMCR, and IPR standards are constructed from
     concentration standards.
 
-    Attributes
-    ----------
+    """
+
     pub_year: HMGPubYear
-        Year of publication of the U.S. Horizontal Merger Guidelines (HMG);
-        1992, 2010, or 2023
-    safeharbor: GuidelinesSTD
-        ΔHHI safeharbor bound, default recapture rate, GUPPI bound and
-        diversion ratio limit at ΔHHI safeharbor
-    inferred_presumption: GuidelinesSTD
-        ΔHHI safeharbor bound, default recapture rate, GUPPI bound and
-        diversion ratio limit at enforcement margin for Guidelines
-        presumption of harm, interpreted strictly
-    presumption: GuidelinesSTD
-        ΔHHI safeharbor bound, default recapture rate, GUPPI bound and
-        diversion ratio limit at enforcement margin for Guidelines
-        presumption of harm, as typically interpreted in the literature
-        on merger enforcement
     """
+    Year of publication of the U.S. Horizontal Merger Guidelines (HMG)
+    """
+
+    safeharbor: GuidelinesSTD = field(kw_only=True, default=None)
+    """
+    Negative presumption defined on various measures
 
-    def __init__(self, _pub_year: HMGPubYear = 1992, /):
-        self.pub_year: HMGPubYear = _pub_year
+    ΔHHI safeharbor bound, default recapture rate, GUPPI bound,
+    diversion ratio limit, CMCR, and IPR
+    """
+
+    inferred_presumption: GuidelinesSTD = field(kw_only=True, default=None)
+    """
+    Inferred ΔHHI safeharbor presumption and related measures
+
+    ΔHHI bound inferred from strict numbers-equivalent
+    of (post-merger) HHI presumption, and corresponding default recapture rate,
+    GUPPI bound, diversion ratio limit, CMCR, and IPR
+    """
+
+    presumption: GuidelinesSTD = field(kw_only=True, default=None)
+    """
+    Guidelines ΔHHI safeharbor presumption and related measures
+
+    ΔHHI bound and corresponding default recapture rate, GUPPI bound,
+    diversion ratio limit, CMCR, and IPR
+    """
 
-        # In the 2023 Guidlines, the agencies do not specify a safeharbor
-        # Practically speaking, given resource constraints and loss aversion,
-        # it is likely that staff only investigates mergers that
-        # meet the presumption; nonetheless, the "safeharbor" is set here at
-        # the 1992 level
+    def __attrs_post_init__(self, /):
+        # In the 2023 Guidlines, the agencies do not define a
+        # negative presumption, or safeharbor. Practically speaking,
+        # given resource constraints and loss aversion, it is likely
+        # that staff only investigates mergers that meet the presumption;
+        # thus, here, the tentative delta safeharbor under
+        # the 2023 Guidelines is 100 points
         _hhi_p, _dh_s, _dh_p = {
             1992: (0.18, 0.005, 0.01),
             2010: (0.25, 0.01, 0.02),
             2023: (0.18, 0.01, 0.01),
-        }[_pub_year]
-
-        self.safeharbor = GuidelinesSTD(
-            _dh_s,
-            _r := round_cust((_fc := int(np.ceil(1 / _hhi_p))) / (_fc + 1)),
-            _g_s := gbd_from_dsf(_dh_s, m_star=1.0, r_bar=_r),
-            _dr := round_cust(1 / (_fc + 1)),
-            _cmcr := 0.03,  # Not strictly a Guidelines standard
-            _ipr := _g_s,  # Not strictly a Guidelines standard
+        }[self.pub_year]
+
+        object.__setattr__(
+            self,
+            "safeharbor",
+            GuidelinesSTD(
+                _dh_s,
+                _r := round_cust((_fc := int(np.ceil(1 / _hhi_p))) / (_fc + 1)),
+                _g_s := gbd_from_dsf(_dh_s, m_star=1.0, r_bar=_r),
+                _dr := round_cust(1 / (_fc + 1)),
+                _cmcr := 0.03,  # Not strictly a Guidelines standard
+                _ipr := _g_s,  # Not strictly a Guidelines standard
+            ),
         )
 
         # inferred_presumption is relevant for 2010 Guidelines
-        self.inferred_presumption = (
+        object.__setattr__(
+            self,
+            "inferred_presumption",
+            (
+                GuidelinesSTD(
+                    _dh_i := 2 * (0.5 / _fc) ** 2,
+                    _r_i := round_cust((_fc - 1 / 2) / (_fc + 1 / 2)),
+                    _g_i := gbd_from_dsf(_dh_i, m_star=1.0, r_bar=_r_i),
+                    round_cust((1 / 2) / (_fc - 1 / 2)),
+                    _cmcr,
+                    _g_i,
+                )
+                if self.pub_year == 2010
+                else GuidelinesSTD(
+                    _dh_i := 2 * (1 / (_fc + 1)) ** 2,
+                    _r,
+                    _g_i := gbd_from_dsf(_dh_i, m_star=1.0, r_bar=_r),
+                    _dr,
+                    _cmcr,
+                    _g_i,
+                )
+            ),
+        )
+
+        object.__setattr__(
+            self,
+            "presumption",
             GuidelinesSTD(
-                _dh_i := 2 * (_s := 1 / (_fc + 1)) * _s,
+                _dh_p,
                 _r,
-                _g_i := gbd_from_dsf(_dh_i, m_star=1.0, r_bar=_r),
+                _g_p := gbd_from_dsf(_dh_p, m_star=1.0, r_bar=_r),
                 _dr,
                 _cmcr,
-                _g_i,
-            )
-            if _pub_year in (1992, 2023)
-            else GuidelinesSTD(
-                _dh_i := 2 * (_s := 0.5 / _fc) * _s,
-                _r_i := round_cust((_fc - 1 / 2) / (_fc + 1 / 2)),
-                _g_i := gbd_from_dsf(_dh_i, m_star=1.0, r_bar=_r_i),
-                round_cust((1 / 2) / (_fc - 1 / 2)),
-                _cmcr,
-                _g_i,
-            )
-        )
-
-        self.presumption = GuidelinesSTD(
-            _dh_p,
-            _r,
-            _g_p := gbd_from_dsf(_dh_p, m_star=1.0, r_bar=_r),
-            _dr,
-            _cmcr,
-            _ipr := _g_p,
+                _ipr := _g_p,
+            ),
         )
 
 
@@ -521,7 +562,7 @@ def dh_area_quad(_dh_val: float = 0.01, /, *, dh_dps: int = 9) -> float:
 
 def delta_hhi_boundary(
     _dh_val: float = 0.01, /, *, dh_dps: int = 5
-) -> tuple[NDArray[np.float64], float]:
+) -> GuidelinesBoundary:
     """
     Generate the list of share combination on the ΔHHI boundary.
 
@@ -557,7 +598,7 @@ def delta_hhi_boundary(
     _dh_bdry_pts = np.row_stack((np.flip(_dh_half, 0), np.flip(_dh_half[1:], 1)))
 
     _s_1_pts, _s_2_pts = np.split(_dh_bdry_pts, 2, axis=1)
-    return (
+    return GuidelinesBoundary(
         np.column_stack((
             np.array(_s_1_pts, np.float64),
             np.array(_s_2_pts, np.float64),
@@ -568,7 +609,7 @@ def delta_hhi_boundary(
 
 def combined_share_boundary(
     _s_intcpt: float = 0.0625, /, *, bdry_dps: int = 10
-) -> tuple[NDArray[np.float64], float]:
+) -> GuidelinesBoundary:
     """
     Share combinations on the merging-firms' combined share boundary.
 
@@ -592,7 +633,7 @@ def combined_share_boundary(
     _s_mid = _s_intcpt / 2
 
     _s1_pts = (0, _s_mid, _s_intcpt)
-    return (
+    return GuidelinesBoundary(
         np.column_stack((
             np.array(_s1_pts, np.float64),
             np.array(_s1_pts[::-1], np.float64),
@@ -603,7 +644,7 @@ def combined_share_boundary(
 
 def hhi_pre_contrib_boundary(
     _hhi_contrib: float = 0.03125, /, *, bdry_dps: int = 5
-) -> tuple[NDArray[np.float64], float]:
+) -> GuidelinesBoundary:
     """
     Share combinations on the premerger HHI contribution boundary.
 
@@ -627,15 +668,15 @@ def hhi_pre_contrib_boundary(
     _s_1 = np.array(mp.arange(_s_mid, -_bdry_step_sz, -_bdry_step_sz), np.float64)
     _s_2 = np.sqrt(_hhi_contrib - _s_1**2).astype(np.float64)
     _bdry_pts_mid = np.column_stack((_s_1, _s_2))
-    return (
+    return GuidelinesBoundary(
         np.row_stack((np.flip(_bdry_pts_mid, 0), np.flip(_bdry_pts_mid[1:], 1))),
         round(float(mp.pi * _hhi_contrib / 4), bdry_dps),
     )
 
 
-def shrratio_mgnsym_boundary_max(
+def shrratio_boundary_max(
     _delta_star: float = 0.075, _r_val: float = 0.80, /, *, gbd_dps: int = 10
-) -> tuple[NDArray[np.float64], float]:
+) -> GuidelinesBoundary:
     """
     Share combinations on the minimum GUPPI boundary with symmetric
     merging-firm margins.
@@ -670,7 +711,7 @@ def shrratio_mgnsym_boundary_max(
 
     _s1_pts = (0, _s_mid, _s_intcpt)
 
-    return (
+    return GuidelinesBoundary(
         np.column_stack((
             np.array(_s1_pts, np.float64),
             np.array(_s1_pts[::-1], np.float64),
@@ -679,14 +720,14 @@ def shrratio_mgnsym_boundary_max(
     )
 
 
-def shrratio_mgnsym_boundary_min(
+def shrratio_boundary_min(
     _delta_star: float = 0.075,
     _r_val: float = 0.80,
     /,
     *,
     recapture_spec: str = "inside-out",
     gbd_dps: int = 10,
-) -> tuple[NDArray[np.float64], float]:
+) -> GuidelinesBoundary:
     """
     Share combinations on the minimum GUPPI boundary, with symmetric
     merging-firm margins.
@@ -749,10 +790,12 @@ def shrratio_mgnsym_boundary_min(
     else:
         _s1_pts, _gbd_area = np.array((0, _s_mid, _s_intcpt), np.float64), _s_mid
 
-    return np.column_stack((_s1_pts, _s1_pts[::-1])), round(float(_gbd_area), gbd_dps)
+    return GuidelinesBoundary(
+        np.column_stack((_s1_pts, _s1_pts[::-1])), round(float(_gbd_area), gbd_dps)
+    )
 
 
-def shrratio_mgnsym_boundary_wtd_avg(
+def shrratio_boundary_wtd_avg(
     _delta_star: float = 0.075,
     _r_val: float = 0.80,
     /,
@@ -761,7 +804,7 @@ def shrratio_mgnsym_boundary_wtd_avg(
     wgtng_policy: Literal["own-share", "cross-product-share"] | None = "own-share",
     recapture_spec: Literal["inside-out", "proportional"] = "inside-out",
     gbd_dps: int = 5,
-) -> tuple[NDArray[np.float64], float]:
+) -> GuidelinesBoundary:
     """
     Share combinations for the share-weighted average GUPPI boundary with symmetric
     merging-firm margins.
@@ -947,20 +990,20 @@ def shrratio_mgnsym_boundary_wtd_avg(
         np.float64
     )
     # Points defining boundary to point-of-symmetry
-    return (
+    return GuidelinesBoundary(
         np.row_stack((np.flip(_gbdry_points, 0), np.flip(_gbdry_points[1:], 1))),
         round(float(_gbdry_area_total), gbd_dps),
     )
 
 
-def shrratio_mgnsym_boundary_xact_avg(
+def shrratio_boundary_xact_avg(
     _delta_star: float = 0.075,
     _r_val: float = 0.80,
     /,
     *,
     recapture_spec: Literal["inside-out", "proportional"] = "inside-out",
     gbd_dps: int = 5,
-) -> tuple[NDArray[np.float64], float]:
+) -> GuidelinesBoundary:
     """
     Share combinations for the simple average GUPPI boundary with symmetric
     merging-firm margins.
@@ -1115,13 +1158,13 @@ def shrratio_mgnsym_boundary_xact_avg(
     ) - np.power(_s_mid, 2)
 
     _s_1_pts, _s_2_pts = np.split(_gbdry_points, 2, axis=1)
-    return (
+    return GuidelinesBoundary(
         np.column_stack((np.array(_s_1_pts), np.array(_s_2_pts))),
         round(float(_gbdry_area_simpson), gbd_dps),
     )
 
 
-def shrratio_mgnsym_boundary_avg(
+def shrratio_boundary_avg(
     _delta_star: float = 0.075,
     _r_val: float = 0.80,
     /,
@@ -1129,12 +1172,16 @@ def shrratio_mgnsym_boundary_avg(
     avg_method: Literal["arithmetic", "geometric", "distance"] = "arithmetic",
     recapture_spec: Literal["inside-out", "proportional"] = "inside-out",
     gbd_dps: int = 5,
-) -> tuple[NDArray[np.float64], float]:
+) -> GuidelinesBoundary:
     """
     Share combinations along the average GUPPI boundary, with
     symmetric merging-firm margins.
 
-    Faster than calling shrratio_mgnsym_boundary_avg(wgtng_policy=None).
+    Reimplements the unweighted average and distance estimations from function,
+    `shrratio_boundary_wtd_avg`. This reimplementation
+    is primarifly useful for testing the output of `shrratio_boundary_wtd_avg`
+    as it tests considerably slower.
+
 
     Parameters
     ----------
@@ -1234,13 +1281,13 @@ def shrratio_mgnsym_boundary_avg(
     ) - mp.power(_s_mid, 2)
 
     _gbdry_points = np.array(_gbdry_points, np.float64)
-    return (
+    return GuidelinesBoundary(
         np.row_stack((np.flip(_gbdry_points, 0), np.flip(_gbdry_points[1:], 1))),
         round(float(_gbd_prtlarea), gbd_dps),
     )
 
 
-def shrratio_mgnsym_boundary_distance(
+def shrratio_boundary_distance(
     _delta_star: float = 0.075,
     _r_val: float = 0.80,
     /,
@@ -1249,9 +1296,16 @@ def shrratio_mgnsym_boundary_distance(
     wgtng_policy: Literal["own-share", "cross-product-share"] | None = "own-share",
     recapture_spec: Literal["inside-out", "proportional"] = "inside-out",
     gbd_dps: int = 5,
-) -> tuple[NDArray[np.float64], float]:
+) -> GuidelinesBoundary:
     """
-    Share combinations for the GUPPI boundaries using various aggregators with symmetric merging-firm margins.
+    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 primarifly useful for testing the output of `shrratio_boundary_wtd_avg`
+    as it tests considerably slower.
 
     Parameters
     ----------
@@ -1389,7 +1443,7 @@ def shrratio_mgnsym_boundary_distance(
         np.float64
     )
     # Points defining boundary to point-of-symmetry
-    return (
+    return GuidelinesBoundary(
         np.row_stack((np.flip(_gbdry_points, 0), np.flip(_gbdry_points[1:], 1))),
         round(float(_gbdry_area_total), gbd_dps),
     )

{mergeron-2024.738936.2 → mergeron-2024.738940.0}/src/mergeron/examples/concentration_as_diversion.py

@@ -26,13 +26,13 @@ from math import sqrt
 from pathlib import Path
 from typing import Any, Literal
 
-import matplotlib.axis
+import matplotlib.axes as mpa
 from joblib import Parallel, cpu_count, delayed
 from numpy import pi
 from xlsxwriter import Workbook
 
 import mergeron.core.excel_helper as xlh
-import mergeron.core.guidelines_standards as gsf
+import mergeron.core.guidelines_standards as gsl
 import mergeron.ext.tol_colors as ptcolor
 from mergeron import DATA_DIR
 
@@ -46,20 +46,20 @@ BDRY_SPECS_DICT: Mapping[str, Mapping[str, Any]] = {
         "title_str": "ΔHHI boundary",
         "sheet_name": "ΔHHI",
         "func_str": R"\Delta HHI",
-        "func": gsf.delta_hhi_boundary,
+        "func": gsl.delta_hhi_boundary,
     },
     "OSWAG Own-shr-wtd Div Ratio Index": {
         "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": gsf.shrratio_mgnsym_boundary_wtd_avg,
+        "func": gsl.shrratio_boundary_wtd_avg,
         "func_kwargs": {"wgtng_policy": "own-share", "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": gsf.shrratio_mgnsym_boundary_wtd_avg,
+        "func": gsl.shrratio_boundary_wtd_avg,
         "func_kwargs": {
             "wgtng_policy": "own-share",
             "recapture_spec": RECAPTURE_SPEC,
@@ -70,40 +70,44 @@ BDRY_SPECS_DICT: Mapping[str, Mapping[str, Any]] = {
         "title_str": "Aggregated-diversion-ratio boundary, minimum",
         "sheet_name": "OSWAG, minimum",
         "func_str": R"\min (d_{12}, d_{21})",
-        "func": gsf.shrratio_mgnsym_boundary_min,
+        "func": gsl.shrratio_boundary_min,
         "func_kwargs": {"recapture_spec": RECAPTURE_SPEC},
     },
     "SAG Combined Share": {
         "title_str": "Combined Share boundary",
         "sheet_name": "SAG, combined-share",
         "func_str": R"s_M",
-        "func": gsf.combined_share_boundary,
+        "func": gsl.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": gsf.shrratio_mgnsym_boundary_avg,
-        "func_kwargs": {"recapture_spec": RECAPTURE_SPEC, "avg_method": "distance"},
+        "func": gsl.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": gsf.shrratio_mgnsym_boundary_xact_avg,
+        "func": gsl.shrratio_boundary_xact_avg,
         "func_kwargs": {"recapture_spec": RECAPTURE_SPEC},
     },
     "CPSWAG Premerger HHI-contribution": {
         "title_str": "Premerger HHI-contribution boundary",
         "sheet_name": "CPSWAG, HHI-contrib-pre",
         "func_str": R"HHI_M^{pre}",
-        "func": gsf.hhi_pre_contrib_boundary,
+        "func": gsl.hhi_pre_contrib_boundary,
     },
     "CPSWAG Cross-product-shr-wtd Div Ratio Index": {
         "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": gsf.shrratio_mgnsym_boundary_wtd_avg,
+        "func": gsl.shrratio_boundary_wtd_avg,
         "func_kwargs": {
             "wgtng_policy": "cross-product-share",
             "recapture_spec": RECAPTURE_SPEC,
@@ -113,7 +117,7 @@ BDRY_SPECS_DICT: Mapping[str, Mapping[str, Any]] = {
         "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": gsf.shrratio_mgnsym_boundary_wtd_avg,
+        "func": gsl.shrratio_boundary_wtd_avg,
         "func_kwargs": {
             "wgtng_policy": "cross-product-share",
             "recapture_spec": RECAPTURE_SPEC,
@@ -124,7 +128,7 @@ BDRY_SPECS_DICT: Mapping[str, Mapping[str, Any]] = {
         "title_str": "Aggregated-diversion-ratio boundary, maximum",
         "sheet_name": "CPSWAG, maximum",
         "func_str": R"\max (d_{12}, d_{21})",
-        "func": gsf.shrratio_mgnsym_boundary_max,
+        "func": gsl.shrratio_boundary_max,
     },
 }
 
@@ -138,7 +142,7 @@ def tabulate_boundary_stats(_gpubyr: Literal[1992, 2010, 2023], /) -> None:
         are drawn
 
     """
-    gso = gsf.GuidelinesStandards(_gpubyr)
+    gso = gsl.GuidelinesStandards(_gpubyr)
     _dhhi_val, _r_val, _g_val = (
         getattr(gso.presumption, _f) for _f in ("delta", "rec", "guppi")
     )
@@ -196,7 +200,7 @@ def _dhhi_stats(
 
     _delta_val = _s_mid / (1 - _s_mid)
     if _dhhi_val * 1e4 in (50, 100, 200):
-        _delta_val = gsf.round_cust(_r_val * _delta_val) / _r_val
+        _delta_val = gsl.round_cust(_r_val * _delta_val) / _r_val
     _divr_val = _r_val * _delta_val
 
     print(
@@ -221,7 +225,7 @@ def _dhhi_stats(
 def _bdry_stats_col(
     _bdry_spec: str, _dhhi_val: float, _delta_val: float, _r_val: float, /
 ) -> tuple[str, str]:
-    _dhhi_prob = 2 * gsf.dh_area(_dhhi_val)
+    _dhhi_prob = 2 * gsl.dh_area(_dhhi_val)
     _cs_prob = 2 * _dhhi_val
     _hhi_m_pre_prob = pi * _dhhi_val / 2
 
@@ -258,7 +262,7 @@ def plot_and_save_boundary_coords(
     /,
     layout: Literal["collected", "distributed"] = "collected",
 ) -> None:
-    gso = gsf.GuidelinesStandards(_gpubyr)
+    gso = gsl.GuidelinesStandards(_gpubyr)
 
     _hmg_standards_strings_dict = {
         "distributed": ("presumption", "inferred presumption", "safeharbor"),
@@ -272,7 +276,7 @@ def plot_and_save_boundary_coords(
         )
 
     # Initialize plot area
-    _plt, _my_fig1, _ax1, _set_axis_def = gsf.boundary_plot()
+    _plt, _my_fig1, _ax1, _set_axis_def = gsl.boundary_plot()
 
     _divr_agg_methods = ("OSWAG", "SAG", "CPSWAG")
 
@@ -323,7 +327,7 @@ def plot_and_save_boundary_coords(
 
         _fig_leg = _ax1.legend(
             loc="upper right",
-            bbox_to_anchor=(0.995, 0.995),
+            bbox_to_anchor=(0.995, 0.999),
             shadow=True,
             fancybox=False,
             frameon=False,
@@ -332,9 +336,6 @@ def plot_and_save_boundary_coords(
         _fig_leg.set_in_layout(False)
 
         for _bndry_name in _bndry_data_dict:
-            # if _bndry_name == "ΔHHI":  # and _divr_agg_method != "OSWAG" and
-            #     continue
-
             boundary_data_to_worksheet(
                 _bndry_name,
                 _dhhi_val_str,
@@ -347,15 +348,14 @@ def plot_and_save_boundary_coords(
     _fig_savepath = DATA_DIR / rf"{PROG_PATH.stem}_{_gpubyr}.pdf"
     _my_fig1.savefig(_fig_savepath)
     print()
-    del _divr_agg_method
 
 
 def gen_plot_boundary(
     _bndry_data_dict: Mapping[str, Sequence[tuple[float]]],
-    _gso: gsf.GuidelinesStandards,
+    _gso: gsl.GuidelinesStandards,
     _gs_str: str,
     _bdry_spec: tuple[str, Mapping[str, Any]],
-    _ax1: matplotlib.axes.Axes,
+    _ax1: mpa.Axes,
     /,
 ) -> tuple[tuple[float], tuple[float]]:
     """
@@ -366,7 +366,7 @@ def gen_plot_boundary(
     _bndry_data_dict
         mapping for storing boundary coordinates for each plotted boundary
     _gso
-        gsf.GuidelinesStandards instance of tuples listing
+        gsl.GuidelinesStandards instance of tuples listing
         concentration standard, default recapture-rate, GUPPI bound,
         and diversion ratio bound for "safeharbor", "weak presumption",
         and "presumption", where "weak presumption" represents an alternative
@@ -378,7 +378,7 @@ def gen_plot_boundary(
         a mapping detailing the  boundary function specification including
         boundary function name and keyword parameters
     _ax1
-        matplotlib axis object for plots
+        matplotlib Axes object for plots
 
     Returns
     -------
@@ -483,7 +483,7 @@ def gen_plot_boundary(
 
 
 def _plot_annotator(
-    _ax: matplotlib.axes.Axes,
+    _ax: mpa.Axes,
     _a_str: str,
     _data_pt: tuple[float, float],
     _note_offset: tuple[float, float],
@@ -583,7 +583,7 @@ def boundary_data_to_worksheet(
         _xl_sheet,
         _bndry_points,
         _results_top_row,
-        cell_format=xlh.CFmt.PCT_NUM,
+        cell_format=xlh.CFmt.PCT_NUM,  # type: ignore
     )
 
     # Draw a bottom border