mergeron 2024.738936.0__py3-none-any.whl → 2024.738940.0__py3-none-any.whl

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,19 +11,38 @@ 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
 
 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
@@ -32,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
+    """
 
-        # 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
+    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
+    """
+
+    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,
+            ),
         )
 
 
@@ -168,7 +210,7 @@ def lerp(
     /,
 ) -> float | mpf | NDArray[np.float64]:
     """
-    From the C++ standard function of the same name.
+    From the function of the same name in the C++ standard [2]_
 
     Constructs the weighted average, :math:`w_1 x_1 + w_2 x_2`, where
     :math:`w_1 = 1 - r` and :math:`w_2 = r`.
@@ -178,21 +220,35 @@ def lerp(
     _x1, _x2
         bounds :math:`x_1, x_2` to interpolate between.
     _r
-        interpolation weight :math:`r` assigned to :math:`x_2`.
+        interpolation weight :math:`r` assigned to :math:`x_2`
 
     Returns
     -------
-        The linear interpolation, or weighted average, :math:`x_1 (1 - r) + x_2 r`.
+        The linear interpolation, or weighted average,
+        :math:`x_1 + r \\cdot (x_1 - x_2) \\equiv (1 - r) \\cdot x_1 + r \\cdot x_2`.
 
     Raises
     ------
     ValueError
         If the interpolation weight is not in the interval, :math:`[0, 1]`.
 
+    References
+    ----------
+
+    .. [2] C++ Reference, https://en.cppreference.com/w/cpp/numeric/lerp
+
     """
+
     if not 0 <= _r <= 1:
         raise ValueError("Specified interpolation weight must lie in [0, 1].")
-    return _x2 * _r + _x1 * (1 - _r)
+    elif _r == 0:
+        return _x1
+    elif _r == 1:
+        return _x2
+    elif _r == 0.5:
+        return 1 / 2 * (_x1 + _x2)
+    else:
+        return _r * _x2 + (1 - _r) * _x1
 
 
 def gbd_from_dsf(
@@ -506,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.
 
@@ -542,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),
@@ -552,8 +608,8 @@ def delta_hhi_boundary(
 
 
 def combined_share_boundary(
-    _s_incpt: float = 0.0625, /, *, bdry_dps: int = 10
-) -> tuple[NDArray[np.float64], float]:
+    _s_intcpt: float = 0.0625, /, *, bdry_dps: int = 10
+) -> GuidelinesBoundary:
     """
     Share combinations on the merging-firms' combined share boundary.
 
@@ -563,7 +619,7 @@ def combined_share_boundary(
 
     Parameters
     ----------
-    _s_incpt:
+    _s_intcpt:
         Merging-firms' combined share.
     bdry_dps
         Number of decimal places for rounding reported shares.
@@ -573,22 +629,22 @@ def combined_share_boundary(
         Array of share-pairs, area under boundary.
 
     """
-    _s_incpt = mpf(f"{_s_incpt}")
-    _s_mid = _s_incpt / 2
+    _s_intcpt = mpf(f"{_s_intcpt}")
+    _s_mid = _s_intcpt / 2
 
-    _s1_pts = (0, _s_mid, _s_incpt)
-    return (
+    _s1_pts = (0, _s_mid, _s_intcpt)
+    return GuidelinesBoundary(
         np.column_stack((
             np.array(_s1_pts, np.float64),
             np.array(_s1_pts[::-1], np.float64),
         )),
-        round(float(_s_incpt * _s_mid), bdry_dps),
+        round(float(_s_intcpt * _s_mid), bdry_dps),
     )
 
 
 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.
 
@@ -612,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.
@@ -650,28 +706,28 @@ def shrratio_mgnsym_boundary_max(
     # of function call with other shrratio_mgnsym_boundary functions
     del _r_val
     _delta_star = mpf(f"{_delta_star}")
-    _s_incpt = _delta_star
+    _s_intcpt = _delta_star
     _s_mid = _delta_star / (1 + _delta_star)
 
-    _s1_pts = (0, _s_mid, _s_incpt)
+    _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),
         )),
-        round(float(_s_incpt * _s_mid), gbd_dps),  # simplified calculation
+        round(float(_s_intcpt * _s_mid), gbd_dps),  # simplified calculation
     )
 
 
-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.
@@ -710,7 +766,7 @@ def shrratio_mgnsym_boundary_min(
         )
 
     _delta_star = mpf(f"{_delta_star}")
-    _s_incpt = mpf("1.00")
+    _s_intcpt = mpf("1.00")
     _s_mid = _delta_star / (1 + _delta_star)
 
     if recapture_spec == "inside-out":
@@ -725,19 +781,21 @@ def shrratio_mgnsym_boundary_min(
                 _smin_nr / _guppi_bdry_env_dr,
                 _s_mid,
                 _smax_nr / _guppi_bdry_env_dr,
-                _s_incpt,
+                _s_intcpt,
             ),
             np.float64,
         )
 
         _gbd_area = (_smin_nr + (_smax_nr - _smin_nr) * _s_mid) / _guppi_bdry_env_dr
     else:
-        _s1_pts, _gbd_area = np.array((0, _s_mid, _s_incpt), np.float64), _s_mid
+        _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,
     /,
@@ -746,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.
@@ -842,10 +900,12 @@ def shrratio_mgnsym_boundary_wtd_avg(
     _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
     _gbd_step_sz = mp.power(10, -gbd_dps)
     _theta = _gbd_step_sz * (10 if wgtng_policy == "cross-product-share" else 1)
     for _s_1 in mp.arange(_s_mid - _gbd_step_sz, 0, -_gbd_step_sz):
@@ -883,12 +943,12 @@ def shrratio_mgnsym_boundary_wtd_avg(
                     _delta_test = lerp(_de_1, _de_2, _r)
 
             if wgtng_policy == "cross-product-share":
-                test_flag, incr_decr = (_delta_test > _delta_star, -1)
+                _test_flag, _incr_decr = (_delta_test > _delta_star, -1)
             else:
-                test_flag, incr_decr = (_delta_test < _delta_star, 1)
+                _test_flag, _incr_decr = (_delta_test < _delta_star, 1)
 
-            if test_flag:
-                _s_2 += incr_decr * _gbd_step_sz
+            if _test_flag:
+                _s_2 += _incr_decr * _gbd_step_sz
             else:
                 break
 
@@ -916,28 +976,34 @@ def shrratio_mgnsym_boundary_wtd_avg(
     # Area under boundary
     _gbdry_area_total = 2 * _gbd_prtlarea - mp.power(_s_mid, 2)
 
-    _gbdry_points = np.row_stack((
-        _gbdry_points,
-        (
-            mpf("0.0"),
-            _delta_star if wgtng_policy == "cross-product-share" else mpf("1.0"),
-        ),
-    )).astype(np.float64)
+    match wgtng_policy:
+        case "cross-product-share":
+            _s_intcpt = _delta_star
+        case "own-product-share":
+            _s_intcpt = mpf("1.0")
+        case None if avg_method == "distance":
+            _s_intcpt = _delta_star * mp.sqrt("2")
+        case _:
+            _s_intcpt = _s_2_pre
+
+    _gbdry_points = np.row_stack((_gbdry_points, (mpf("0.0"), _s_intcpt))).astype(
+        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.
@@ -1009,13 +1075,13 @@ def shrratio_mgnsym_boundary_xact_avg(
     _gbdry_points_start = np.array([(_s_mid, _s_mid)])
     _s_1 = np.array(mp.arange(_s_mid - _gbd_step_sz, 0, -_gbd_step_sz), np.float64)
     if recapture_spec == "inside-out":
-        _s_incpt = mp.fdiv(
+        _s_intcpt = mp.fdiv(
             mp.fsub(
                 2 * _delta_star * _r_val + 1, mp.fabs(2 * _delta_star * _r_val - 1)
             ),
             2 * mpf(f"{_r_val}"),
         )
-        _nr_t1 = 1 + 2 * _delta_star * _r_val * (1 - _s_1) - _s_1 * (1 - _r_val)
+        _nr_t1 = 1 + 2 * _delta_star * _r_val * (1 - _s_1) - _s_1 * (1 - _r_val)  # type: ignore
 
         _nr_sqrt_mdr = 4 * _delta_star * _r_val
         _nr_sqrt_mdr2 = _nr_sqrt_mdr * _r_val
@@ -1040,9 +1106,9 @@ def shrratio_mgnsym_boundary_xact_avg(
 
         _nr_t2_s1 = _nr_sqrt_s1sq + _nr_sqrt_s1 + _nr_sqrt_nos1
 
-        if not np.isclose(
-            np.einsum("i->", _nr_t2_mdr.astype(np.float64)),  # from mpf to float64
-            np.einsum("i->", _nr_t2_s1.astype(np.float64)),
+        if not np.isclose(  # type: ignore
+            np.einsum("i->", _nr_t2_mdr.astype(np.float64)),  # type: ignore from mpf to float64
+            np.einsum("i->", _nr_t2_s1.astype(np.float64)),  # type: ignore from mpf to float64
             rtol=0,
             atol=0.5 * gbd_dps,
         ):
@@ -1054,7 +1120,7 @@ def shrratio_mgnsym_boundary_xact_avg(
         _s_2 = (_nr_t1 - np.sqrt(_nr_t2_s1)) / (2 * _r_val)
 
     else:
-        _s_incpt = mp.fsub(_delta_star + 1 / 2, mp.fabs(_delta_star - 1 / 2))
+        _s_intcpt = mp.fsub(_delta_star + 1 / 2, mp.fabs(_delta_star - 1 / 2))
         _s_2 = (
             (1 / 2)
             + _delta_star
@@ -1069,7 +1135,7 @@ def shrratio_mgnsym_boundary_xact_avg(
         )
 
     _gbdry_points_inner = np.column_stack((_s_1, _s_2))
-    _gbdry_points_end = np.array([(mpf("0.0"), _s_incpt)], np.float64)
+    _gbdry_points_end = np.array([(mpf("0.0"), _s_intcpt)], np.float64)
 
     _gbdry_points = np.row_stack((
         _gbdry_points_end,
@@ -1092,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,
     /,
@@ -1106,11 +1172,17 @@ 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.
 
+    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
     ----------
     _delta_star
@@ -1118,7 +1190,7 @@ def shrratio_mgnsym_boundary_avg(
     _r_val
         Recapture ratio.
     avg_method
-        Whether "arithmetic", "geometric", or "root-mean-square".
+        Whether "arithmetic", "geometric", or "distance".
     recapture_spec
         Whether recapture-ratio is MNL-consistent ("inside-out") or has fixed
         value for both merging firms ("proportional").
@@ -1137,7 +1209,7 @@ def shrratio_mgnsym_boundary_avg(
             "Margin-adjusted benchmark share ratio cannot exceed 1."
         )
 
-    if avg_method not in (_avgmthds := ("arithmetic", "geometric", "root-mean-square")):
+    if avg_method not in (_avgmthds := ("arithmetic", "geometric", "distance")):
         raise ValueError(
             f"Averarging method, {f'"{avg_method}"'} is invalid. "
             f"Must be one of, {_avgmthds!r}."
@@ -1151,18 +1223,21 @@ def shrratio_mgnsym_boundary_avg(
 
     _delta_star = mpf(f"{_delta_star}")
     _s_mid = _delta_star / (1 + _delta_star)
-    _gbd_step_sz = mp.power(10, -gbd_dps)
 
+    # initial conditions
     _s_2 = _s_mid
     _s_2_oddval = True
     _s_2_oddsum = 0
     _s_2_evnsum = 0
     _gbdry_points = [(_s_mid, _s_mid)]
+
+    # parameters for iteration
+    _gbd_step_sz = mp.power(10, -gbd_dps)
     for _s_1 in mp.arange(_s_mid, 0, -_gbd_step_sz):
         _s_1 -= _gbd_step_sz
         while True:
-            _shratio_12 = _s_2 / (1 - _s_1)
-            _shratio_21 = (
+            _delta_12 = _s_2 / (1 - _s_1)
+            _delta_21 = (
                 _s_1 / (1 - _s_2)
                 if recapture_spec == "proportional"
                 else _s_1 / (1 - lerp(_s_1, _s_2, _r_val))
@@ -1170,13 +1245,21 @@ def shrratio_mgnsym_boundary_avg(
 
             match avg_method:
                 case "geometric":
-                    _small_d = mp.sqrt(_shratio_12 * _shratio_21)
+                    _delta_test = mp.sqrt(_delta_12 * _delta_21)
                 case "distance":
-                    _small_d = mp.sqrt(mp.fdiv((_shratio_12**2 + _shratio_21**2), "2"))
+                    # _delta_test = mp.sqrt(mp.fdiv((_delta_12**2 + _delta_21**2), "2"))
+                    _delta_test = mp.sqrt(
+                        mp.fdiv(
+                            mp.fsum(
+                                mp.power(f"{_g}", "2") for _g in (_delta_12, _delta_21)
+                            ),
+                            "2",
+                        )
+                    )
                 case _:
-                    _small_d = mp.fdiv(_shratio_12 + _shratio_21, "2")
+                    _delta_test = mp.fdiv(_delta_12 + _delta_21, "2")
 
-            if _small_d < _delta_star:
+            if _delta_test < _delta_star:
                 _s_2 += _gbd_step_sz
             else:
                 break
@@ -1189,16 +1272,178 @@ def shrratio_mgnsym_boundary_avg(
 
     # Starting at _s_id - _gbd_step_sz means _s_1 is not always
     # an even multiple of _gbd_step_sz
-    _s_incpt = _s_2
+    _s_intcpt = _s_2
 
     _gbd_prtlarea = 2 * _gbd_step_sz * (
         mp.fmul(4 / 3, _s_2_oddsum)
         + mp.fmul(2 / 3, _s_2_evnsum)
-        + mp.fmul(1 / 3, _s_mid + _s_incpt)
+        + mp.fmul(1 / 3, _s_mid + _s_intcpt)
     ) - 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_boundary_distance(
+    _delta_star: float = 0.075,
+    _r_val: float = 0.80,
+    /,
+    *,
+    avg_method: Literal["arithmetic", "distance"] = "arithmetic",
+    wgtng_policy: Literal["own-share", "cross-product-share"] | None = "own-share",
+    recapture_spec: Literal["inside-out", "proportional"] = "inside-out",
+    gbd_dps: 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 primarifly useful for testing the output of `shrratio_boundary_wtd_avg`
+    as it tests considerably slower.
+
+    Parameters
+    ----------
+    _delta_star
+        corollary to GUPPI bound (:math:`\\overline{g} / (m^* \\cdot \\overline{r})`)
+    _r_val
+        recapture ratio
+    avg_method
+        Whether "arithmetic", "geometric", or "distance".
+    wgtng_policy
+        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").
+    gbd_dps
+        Number of decimal places for rounding returned shares and area.
+
+    Returns
+    -------
+        Array of share-pairs, area under boundary.
+
+    """
+
+    if _delta_star > 1:
+        raise ValueError(
+            "Margin-adjusted benchmark share ratio, `_delta_star` cannot exceed 1."
+        )
+
+    _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, -gbd_dps)
+    _theta = _gbd_step_sz * (10 if wgtng_policy == "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 wgtng_policy == "cross-product-share" else _s_1,
+                        _s_1 + _s_2,
+                    ),
+                    1 - _w1,
+                )
+                if wgtng_policy
+                else _weights_base
+            )
+
+            match avg_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
+                    )
+
+            if wgtng_policy == "cross-product-share":
+                _test_flag, _incr_decr = (_delta_test > _delta_star, -1)
+            else:
+                _test_flag, _incr_decr = (_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
+
+    _gbd_prtlarea = _gbd_step_sz * (
+        (4 * _s_2_oddsum + 2 * _s_2_evnsum + _s_mid + _delta_star) / 3
+        if wgtng_policy == "cross-product-share"
+        else (
+            (4 * _s_2_oddsum + 2 * _s_2_evnsum + _s_mid + _s_2_pre) / 3
+            + _s_1_pre * (1 + _s_2_pre) / 2
+        )
+    )
+
+    # Area under boundary
+    _gbdry_area_total = 2 * _gbd_prtlarea - mp.power(_s_mid, 2)
+
+    match wgtng_policy:
+        case "cross-product-share":
+            _s_intcpt = _delta_star
+        case "own-product-share":
+            _s_intcpt = mpf("1.0")
+        case None if avg_method == "distance":
+            _s_intcpt = _delta_star * mp.sqrt("2")
+        case None if avg_method == "arithmetic" and recapture_spec == "inside-out":
+            _s_intcpt = mp.fdiv(
+                mp.fsub(
+                    2 * _delta_star * _r_val + 1, mp.fabs(2 * _delta_star * _r_val - 1)
+                ),
+                2 * mpf(f"{_r_val}"),
+            )
+        case None if avg_method == "arithmetic":
+            _s_intcpt = mp.fsub(_delta_star + 1 / 2, mp.fabs(_delta_star - 1 / 2))
+        case _:
+            _s_intcpt = _s_2_pre
+
+    _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), gbd_dps),
+    )