mergeron 2025.739290.6__tar.gz → 2025.739290.7__tar.gz

{mergeron-2025.739290.6 → mergeron-2025.739290.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: mergeron
-Version: 2025.739290.6
+Version: 2025.739290.7
 Summary: Analyze merger enforcement policy using Python
 License: MIT
 Keywords: merger policy analysis,merger guidelines,merger screening,policy presumptions,concentration standards,upward pricing pressure,GUPPI

{mergeron-2025.739290.6 → mergeron-2025.739290.7}/pyproject.toml

@@ -13,7 +13,7 @@ keywords = [
     "upward pricing pressure",
     "GUPPI",
 ]
-version = "2025.739290.6"
+version = "2025.739290.7"
 
 # Classifiers list: https://pypi.org/classifiers/
 classifiers = [

{mergeron-2025.739290.6 → mergeron-2025.739290.7}/src/mergeron/__init__.py

@@ -12,7 +12,7 @@ from ruamel import yaml
 
 _PKG_NAME: str = Path(__file__).parent.stem
 
-VERSION = "2025.739290.6"
+VERSION = "2025.739290.7"
 
 __version__ = VERSION
 

{mergeron-2025.739290.6 → mergeron-2025.739290.7}/src/mergeron/core/__init__.py

@@ -9,7 +9,14 @@ import mpmath  # type: ignore
 import numpy as np
 from attrs import cmp_using, field, frozen
 
-from .. import VERSION, ArrayBIGINT, this_yaml, yaml_rt_mapper  # noqa: TID252
+from .. import (  # noqa: TID252
+    VERSION,
+    ArrayBIGINT,
+    ArrayDouble,
+    this_yaml,
+    yamelize_attrs,
+    yaml_rt_mapper,
+)
 
 __version__ = VERSION
 
@@ -17,6 +24,17 @@ type MPFloat = mpmath.ctx_mp_python.mpf
 type MPMatrix = mpmath.matrix  # type: ignore
 
 
+@frozen
+class GuidelinesBoundary:
+    """Output of a Guidelines boundary function."""
+
+    coordinates: ArrayDouble
+    """Market-share pairs as Cartesian coordinates of points on the boundary."""
+
+    area: float
+    """Area under the boundary."""
+
+
 @frozen
 class INVTableData:
     industry_group: str
@@ -29,6 +47,7 @@ type INVData = MappingProxyType[
 ]
 type INVData_in = Mapping[str, Mapping[str, Mapping[str, INVTableData]]]
 
+yamelize_attrs(INVTableData)
 
 (_, _) = (
     this_yaml.representer.add_representer(
@@ -59,6 +78,16 @@ type INVData_in = Mapping[str, Mapping[str, Mapping[str, INVTableData]]]
     ),
 )
 
+_, _ = (
+    this_yaml.representer.add_representer(
+        MappingProxyType,
+        lambda _r, _d: _r.represent_mapping("!mappingproxy", dict(_d.items())),
+    ),
+    this_yaml.constructor.add_constructor(
+        "!mappingproxy", lambda _c, _n: MappingProxyType(dict(**yaml_rt_mapper(_c, _n)))
+    ),
+)
+
 
 def _dict_from_mapping(_p: Mapping[Any, Any], /) -> dict[Any, Any]:
     retval: dict[Any, Any] = {}
@@ -76,34 +105,3 @@ def _mappingproxy_from_mapping(_p: Mapping[Any, Any], /) -> MappingProxyType[Any
             else {_k: _v}
         )
     return MappingProxyType(retval)
-
-
-_, _ = (
-    this_yaml.representer.add_representer(
-        MappingProxyType,
-        lambda _r, _d: _r.represent_mapping("!mappingproxy", dict(_d.items())),
-    ),
-    this_yaml.constructor.add_constructor(
-        "!mappingproxy", lambda _c, _n: MappingProxyType(yaml_rt_mapper(_c, _n))
-    ),
-)
-
-
-for _typ in (INVTableData,):
-    _, _ = (
-        this_yaml.representer.add_representer(
-            _typ,
-            lambda _r, _d: _r.represent_mapping(
-                f"!{_d.__class__.__name__}",
-                {
-                    _a.name: getattr(_d, _a.name)
-                    for _a in _d.__attrs_attrs__
-                    if _a.name not in {"coordinates", "area"}
-                },
-            ),
-        ),
-        this_yaml.constructor.add_constructor(
-            f"!{_typ.__name__}",
-            lambda _c, _n: globals()[_n.tag.lstrip("!")](**yaml_rt_mapper(_c, _n)),
-        ),
-    )

{mergeron-2025.739290.6 → mergeron-2025.739290.7}/src/mergeron/core/ftc_merger_investigations_data.py

@@ -12,7 +12,7 @@ from __future__ import annotations
 
 import re
 import shutil
-from collections.abc import Sequence
+from collections.abc import Mapping, Sequence
 from operator import itemgetter
 from pathlib import Path
 from types import MappingProxyType
@@ -94,6 +94,10 @@ CNT_FCOUNT_DICT = {
 }
 
 
+def reverse_map(_dict: Mapping[Any, Any]) -> Mapping[Any, Any]:
+    return {_v: _k for _k, _v in _dict.items()}
+
+
 def construct_data(
     _archive_path: Path = INVDATA_ARCHIVE_PATH,
     *,

{mergeron-2025.739290.6 → mergeron-2025.739290.7}/src/mergeron/core/guidelines_boundaries.py

@@ -146,6 +146,15 @@ class GuidelinesThresholds:
 class ConcentrationBoundary:
     """Concentration parameters, boundary coordinates, and area under concentration boundary."""
 
+    threshold: float = field(kw_only=False, default=0.01)
+
+    @threshold.validator
+    def _tv(
+        _instance: ConcentrationBoundary, _attribute: Attribute[float], _value: float, /
+    ) -> None:
+        if not 0 <= _value <= 1:
+            raise ValueError("Concentration threshold must lie between 0 and 1.")
+
     measure_name: Literal[
         "ΔHHI",
         "Combined share",
@@ -165,17 +174,8 @@ class ConcentrationBoundary:
         }:
             raise ValueError(f"Invalid name for a concentration measure, {_value!r}.")
 
-    threshold: float = field(kw_only=False, default=0.01)
-
-    @threshold.validator
-    def _tv(
-        _instance: ConcentrationBoundary, _attribute: Attribute[float], _value: float, /
-    ) -> None:
-        if not 0 <= _value <= 1:
-            raise ValueError("Concentration threshold must lie between 0 and 1.")
-
     precision: int = field(
-        kw_only=False, default=5, validator=validators.instance_of(int)
+        kw_only=True, default=5, validator=validators.instance_of(int)
     )
 
     area: float = field(init=False, kw_only=True)
@@ -284,7 +284,7 @@ class DiversionRatioBoundary:
 
     agg_method: UPPAggrSelector = field(
         kw_only=True,
-        default=UPPAggrSelector.MAX,
+        default=UPPAggrSelector.MIN,
         validator=validators.instance_of(UPPAggrSelector),
     )
     """

{mergeron-2025.739290.6 → mergeron-2025.739290.7}/src/mergeron/core/guidelines_boundary_functions.py

@@ -1,5 +1,6 @@
 import decimal
-from typing import Any, Literal, TypedDict
+from collections.abc import Callable
+from typing import Literal, TypedDict
 
 import matplotlib as mpl
 import matplotlib.axes as mpa
@@ -7,11 +8,10 @@ import matplotlib.patches as mpp
 import matplotlib.pyplot as plt
 import matplotlib.ticker as mpt
 import numpy as np
-from attrs import frozen
 from mpmath import mp, mpf  # type: ignore
 
 from .. import DEFAULT_REC_RATIO, VERSION, ArrayBIGINT, ArrayDouble  # noqa: TID252
-from . import MPFloat
+from . import GuidelinesBoundary, MPFloat
 
 __version__ = VERSION
 
@@ -28,17 +28,6 @@ class ShareRatioBoundaryKeywords(TypedDict, total=False):
     weighting: Literal["own-share", "cross-product-share", None]
 
 
-@frozen
-class GuidelinesBoundary:
-    """Output of a Guidelines boundary function."""
-
-    coordinates: ArrayDouble
-    """Market-share pairs as Cartesian coordinates of points on the boundary."""
-
-    area: float
-    """Area under the boundary."""
-
-
 def dh_area(_delta_bound: float | MPFloat = 0.01, /, *, dps: int = 9) -> float:
     R"""
     Area under the ΔHHI boundary.
@@ -56,7 +45,7 @@ def dh_area(_delta_bound: float | MPFloat = 0.01, /, *, dps: int = 9) -> float:
     .. math::
 
         2 s1 s_2 &= ΔHHI\\
-        _s_1 + s_2 &= 1
+        s_1 + s_2 &= 1
 
     Parameters
     ----------
@@ -113,7 +102,7 @@ def hhi_delta_boundary(
         np.column_stack((_s_1, _delta_bound / (2 * _s_1))).astype(float),
         np.array([(mpf("0.0"), mpf("1.0"))], float),
     ))
-    bdry = np.vstack((half_bdry[::-1], half_bdry[1:, ::-1]))
+    bdry = np.vstack((half_bdry[::-1], half_bdry[1:, ::-1]), dtype=float)
 
     return GuidelinesBoundary(bdry, dh_area(_delta_bound, dps=dps))
 
@@ -141,12 +130,12 @@ def hhi_pre_contrib_boundary(
 
     step_size = mp.power(10, -dps)
     # Range-limit is 0 less a step, which is -1 * step-size
-    _s_1 = np.array(mp.arange(_s_mid, -step_size, -step_size))
-    s_2 = np.sqrt(_hhi_bound - _s_1**2)
-    half_bdry = np.column_stack((_s_1, s_2)).astype(float)
+    s_1 = np.array(mp.arange(_s_mid, -step_size, -step_size))
+    s_2 = np.sqrt(_hhi_bound - s_1**2)
+    half_bdry = np.column_stack((s_1, s_2)).astype(float)
 
     return GuidelinesBoundary(
-        np.vstack((half_bdry[::-1], half_bdry[1:, ::-1])),
+        np.vstack((half_bdry[::-1], half_bdry[1:, ::-1]), dtype=float),
         round(float(mp.pi * _hhi_bound / 4), dps),
     )
 
@@ -178,7 +167,8 @@ def combined_share_boundary(
 
     _s1 = np.array([0, _s_mid, _s_intcpt], float)
     return GuidelinesBoundary(
-        np.column_stack((_s1, _s1[::-1])), round(float(_s_intcpt * _s_mid), dps)
+        np.array(list(zip(_s1, _s1[::-1])), float),
+        round(float(_s_intcpt * _s_mid), dps),
     )
 
 
@@ -211,6 +201,7 @@ def hhi_post_contrib_boundary(
     )
 
 
+# hand-rolled root finding
 def shrratio_boundary_wtd_avg(  # noqa: PLR0914
     _delta_star: float = 0.075,
     _r_val: float = DEFAULT_REC_RATIO,
@@ -252,58 +243,57 @@ def shrratio_boundary_wtd_avg(  # noqa: PLR0914
     is derived and plotted from y-intercept to the ray of symmetry as follows::
 
         from sympy import plot as symplot, solve, symbols
-        _s_1, s_2 = symbols("_s_1 s_2", positive=True)
+        s_1, s_2 = symbols("s_1 s_2", positive=True)
 
         g_val, r_val, m_val = 0.06, 0.80, 0.30
         delta_star = g_val / (r_val * m_val)
 
         # recapture_form == "inside-out"
         oswag = solve(
-            _s_1 * s_2 / (1 - _s_1)
-            + s_2 * _s_1 / (1 - (r_val * s_2 + (1 - r_val) * _s_1))
-            - (_s_1 + s_2) * delta_star,
+            s_1 * s_2 / (1 - s_1)
+            + s_2 * s_1 / (1 - (r_val * s_2 + (1 - r_val) * s_1))
+            - (s_1 + s_2) * delta_star,
             s_2
         )[0]
         symplot(
             oswag,
-            (_s_1, 0., d_hat / (1 + d_hat)),
+            (s_1, 0., d_hat / (1 + d_hat)),
             ylabel=s_2
         )
 
         cpswag = solve(
-            s_2 * s_2 / (1 - _s_1)
-            + _s_1 * _s_1 / (1 - (r_val * s_2 + (1 - r_val) * _s_1))
-            - (_s_1 + s_2) * delta_star,
+            s_2 * s_2 / (1 - s_1)
+            + s_1 * s_1 / (1 - (r_val * s_2 + (1 - r_val) * s_1))
+            - (s_1 + s_2) * delta_star,
             s_2
         )[1]
         symplot(
             cpwag,
-            (_s_1, 0., d_hat / (1 + d_hat)),
-            ylabel=s_2
+            (s_1, 0.0, d_hat / (1 + d_hat)), ylabel=s_2
         )
 
         # recapture_form == "proportional"
         oswag = solve(
-            _s_1 * s_2 / (1 - _s_1)
-            + s_2 * _s_1 / (1 - s_2)
-            - (_s_1 + s_2) * delta_star,
+            s_1 * s_2 / (1 - s_1)
+            + s_2 * s_1 / (1 - s_2)
+            - (s_1 + s_2) * delta_star,
              s_2
         )[0]
         symplot(
             oswag,
-            (_s_1, 0., d_hat / (1 + d_hat)),
+            (s_1, 0., d_hat / (1 + d_hat)),
             ylabel=s_2
         )
 
         cpswag = solve(
-            s_2 * s_2 / (1 - _s_1)
-            + _s_1 * _s_1 / (1 - s_2)
-            - (_s_1 + s_2) * delta_star,
+            s_2 * s_2 / (1 - s_1)
+            + s_1 * s_1 / (1 - s_2)
+            - (s_1 + s_2) * delta_star,
              s_2
         )[1]
         symplot(
             cpswag,
-            (_s_1, 0.0, d_hat / (1 + d_hat)),
+            (s_1, 0.0, d_hat / (1 + d_hat)),
             ylabel=s_2
         )
 
@@ -321,26 +311,22 @@ def shrratio_boundary_wtd_avg(  # noqa: PLR0914
     # parameters for iteration
     _step_size = mp.power(10, -dps)
     theta_ = _step_size * (10 if weighting == "cross-product-share" else 1)
-    for _s_1 in mp.arange(_s_mid - _step_size, 0, -_step_size):
+    for s_1 in mp.arange(_s_mid - _step_size, 0, -_step_size):
         # 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"):
-            # Loss of accuracy at 3-9s and up
-            break
-
         while True:
-            de_1 = s_2 / (1 - _s_1)
+            de_1 = s_2 / (1 - s_1)
             de_2 = (
-                _s_1 / (1 - lerp(_s_1, s_2, _r_val))
+                s_1 / (1 - lerp(s_1, s_2, _r_val))
                 if recapture_form == "inside-out"
-                else _s_1 / (1 - s_2)
+                else s_1 / (1 - s_2)
             )
 
             r_ = (
-                mp.fdiv(_s_1 if weighting == "cross-product-share" else s_2, _s_1 + s_2)
+                mp.fdiv(s_1 if weighting == "cross-product-share" else s_2, s_1 + s_2)
                 if weighting
                 else 0.5
             )
@@ -365,7 +351,7 @@ def shrratio_boundary_wtd_avg(  # noqa: PLR0914
                 break
 
         # Build-up boundary points
-        bdry.append((_s_1, s_2))
+        bdry.append((s_1, s_2))
 
         # Build up area terms
         s_2_oddsum += s_2 if s_2_oddval else 0
@@ -374,7 +360,11 @@ def shrratio_boundary_wtd_avg(  # noqa: PLR0914
 
         # Hold share points
         s_2_pre = s_2
-        s_1_pre = _s_1
+        s_1_pre = s_1
+
+        if (s_1 + s_2) > mpf("0.99875"):
+            # Loss of accuracy at 3-9s and up
+            break
 
     if s_2_oddval:
         s_2_evnsum -= s_2_pre
@@ -412,7 +402,7 @@ def shrratio_boundary_wtd_avg(  # noqa: PLR0914
 
     # Points defining boundary to point-of-symmetry
     return GuidelinesBoundary(
-        np.vstack((bdry_array[::-1], bdry_array[1:, ::-1])),
+        np.vstack((bdry_array[::-1], bdry_array[1:, ::-1]), dtype=float),
         round(float(bdry_area_total), dps),
     )
 
@@ -436,29 +426,29 @@ def shrratio_boundary_xact_avg(  # noqa: PLR0914
 
         from sympy import latex, plot as symplot, solve, symbols
 
-        _s_1, s_2 = symbols("_s_1 s_2")
+        s_1, s_2 = symbols("s_1 s_2")
 
         g_val, r_val, m_val = 0.06, 0.80, 0.30
         d_hat = g_val / (r_val * m_val)
 
         # recapture_form = "inside-out"
         sag = solve(
-            (s_2 / (1 - _s_1))
-            + (_s_1 / (1 - (r_val * s_2 + (1 - r_val) * _s_1)))
+            (s_2 / (1 - s_1))
+            + (s_1 / (1 - (r_val * s_2 + (1 - r_val) * s_1)))
             - 2 * d_hat,
             s_2
         )[0]
         symplot(
             sag,
-            (_s_1, 0., d_hat / (1 + d_hat)),
+            (s_1, 0., d_hat / (1 + d_hat)),
             ylabel=s_2
         )
 
         # recapture_form = "proportional"
-        sag = solve((s_2/(1 - _s_1)) + (_s_1/(1 - s_2)) - 2 * d_hat, s_2)[0]
+        sag = solve((s_2/(1 - s_1)) + (s_1/(1 - s_2)) - 2 * d_hat, s_2)[0]
         symplot(
             sag,
-            (_s_1, 0., d_hat / (1 + d_hat)),
+            (s_1, 0., d_hat / (1 + d_hat)),
             ylabel=s_2
         )
 
@@ -614,7 +604,7 @@ def shrratio_boundary_min(
     _s_mid = _delta_star / (1 + _delta_star)
 
     if recapture_form == "inside-out":
-        # ## Plot envelope of GUPPI boundaries with rk_ = r_bar if sk_ = min(_s_1, s_2)
+        # ## Plot envelope of GUPPI boundaries with rk_ = r_bar if sk_ = min(s_1, s_2)
         # ## See (si_, sj_) in equation~(44), or thereabouts, in paper
         smin_nr = _delta_star * (1 - _r_val)
         smax_nr = 1 - _delta_star * _r_val
@@ -626,7 +616,7 @@ def shrratio_boundary_min(
         s_1, bdry_area = np.array((0, _s_mid, _s_intcpt), float), _s_mid
 
     return GuidelinesBoundary(
-        np.column_stack((s_1, s_1[::-1])), round(float(bdry_area), dps)
+        np.array(list(zip(s_1, s_1[::-1])), float), round(float(bdry_area), dps)
     )
 
 
@@ -659,7 +649,7 @@ def shrratio_boundary_max(
     _s1_pts = (0, _s_mid, _s_intcpt)
 
     return GuidelinesBoundary(
-        np.column_stack((np.array(_s1_pts, float), np.array(_s1_pts[::-1], float))),
+        np.array(list(zip(_s1_pts, _s1_pts[::-1])), float),
         round(float(_s_intcpt * _s_mid), dps),  # simplified calculation
     )
 
@@ -797,51 +787,57 @@ def round_cust(
     return float(f_ * (n_ / f_).quantize(e_, rounding=rounding_mode))
 
 
-def boundary_plot(*, mktshares_plot_flag: bool = True) -> tuple[Any, ...]:
+def boundary_plot(
+    *,
+    mktshare_plot_flag: bool = True,
+    mktshare_axes_flag: bool = True,
+    backend: Literal["pgf"] | str | None = "pgf",
+) -> tuple[mpl.pyplot, mpl.pyplot.Figure, mpl.axes.Axes, Callable[..., mpl.axes.Axes]]:
     """Setup basic figure and axes for plots of safe harbor boundaries.
 
     See, https://matplotlib.org/stable/tutorials/text/pgf.html
     """
 
-    mpl.use("pgf")
-
-    plt.rcParams.update({
-        "pgf.rcfonts": False,
-        "pgf.texsystem": "lualatex",
-        "pgf.preamble": "\n".join([
-            R"\pdfvariable minorversion=7",
-            R"\usepackage{fontspec}",
-            R"\usepackage{luacode}",
-            R"\begin{luacode}",
-            R"local function embedfull(tfmdata)",
-            R'    tfmdata.embedding = "full"',
-            R"end",
-            R"",
-            R"luatexbase.add_to_callback("
-            R'  "luaotfload.patch_font", embedfull, "embedfull"'
-            R")",
-            R"\end{luacode}",
-            R"\usepackage{mathtools}",
-            R"\usepackage{unicode-math}",
-            R"\setmathfont[math-style=ISO]{STIX Two Math}",
-            R"\setmainfont{STIX Two Text}",
-            r"\setsansfont{Fira Sans Light}",
-            R"\setmonofont[Scale=MatchLowercase,]{Fira Mono}",
-            R"\defaultfontfeatures[\rmfamily]{",
-            R"  Ligatures={TeX, Common},",
-            R"  Numbers={Proportional, Lining},",
-            R"  }",
-            R"\defaultfontfeatures[\sffamily]{",
-            R"  Ligatures={TeX, Common},",
-            R"  Numbers={Monospaced, Lining},",
-            R"  LetterSpace=0.50,",
-            R"  }",
-            R"\usepackage[",
-            R"  activate={true, nocompatibility},",
-            R"  tracking=true,",
-            R"  ]{microtype}",
-        ]),
-    })
+    if backend == "pgf":
+        mpl.use("pgf")
+
+        plt.rcParams.update({
+            "pgf.rcfonts": False,
+            "pgf.texsystem": "lualatex",
+            "pgf.preamble": "\n".join([
+                R"\pdfvariable minorversion=7",
+                R"\usepackage{fontspec}",
+                R"\usepackage{luacode}",
+                R"\begin{luacode}",
+                R"local function embedfull(tfmdata)",
+                R'    tfmdata.embedding = "full"',
+                R"end",
+                R"",
+                R"luatexbase.add_to_callback("
+                R'  "luaotfload.patch_font", embedfull, "embedfull"'
+                R")",
+                R"\end{luacode}",
+                R"\usepackage{mathtools}",
+                R"\usepackage{unicode-math}",
+                R"\setmathfont[math-style=ISO]{STIX Two Math}",
+                R"\setmainfont{STIX Two Text}",
+                r"\setsansfont{Fira Sans Light}",
+                R"\setmonofont[Scale=MatchLowercase,]{Fira Mono}",
+                R"\defaultfontfeatures[\rmfamily]{",
+                R"  Ligatures={TeX, Common},",
+                R"  Numbers={Proportional, Lining},",
+                R"  }",
+                R"\defaultfontfeatures[\sffamily]{",
+                R"  Ligatures={TeX, Common},",
+                R"  Numbers={Monospaced, Lining},",
+                R"  LetterSpace=0.50,",
+                R"  }",
+                R"\usepackage[",
+                R"  activate={true, nocompatibility},",
+                R"  tracking=true,",
+                R"  ]{microtype}",
+            ]),
+        })
 
     # Initialize a canvas with a single figure (set of axes)
     fig_ = plt.figure(figsize=(5, 5), dpi=600)
@@ -851,8 +847,8 @@ def boundary_plot(*, mktshares_plot_flag: bool = True) -> tuple[Any, ...]:
         ax1_: mpa.Axes,
         /,
         *,
-        mktshares_plot_flag: bool = False,
-        mktshares_axlbls_flag: bool = False,
+        mktshare_plot_flag: bool = False,
+        mktshare_axes_flag: bool = False,
     ) -> mpa.Axes:
         # Set the width of axis grid lines, and tick marks:
         # both axes, both major and minor ticks
@@ -883,16 +879,7 @@ def boundary_plot(*, mktshares_plot_flag: bool = True) -> tuple[Any, ...]:
             ax1_.yaxis.get_majorticklabels(), horizontalalignment="right", fontsize=6
         )
 
-        if mktshares_plot_flag:
-            # Axis labels
-            if mktshares_axlbls_flag:
-                # x-axis
-                ax1_.set_xlabel("Firm 1 Market Share, $_s_1$", fontsize=10)
-                ax1_.xaxis.set_label_coords(0.75, -0.1)
-                # y-axis
-                ax1_.set_ylabel("Firm 2 Market Share, $s_2$", fontsize=10)
-                ax1_.yaxis.set_label_coords(-0.1, 0.75)
-
+        if mktshare_plot_flag:
             # Plot the ray of symmetry
             ax1_.plot(
                 [0, 1], [0, 1], linewidth=0.5, linestyle=":", color="grey", zorder=1
@@ -944,8 +931,21 @@ def boundary_plot(*, mktshares_plot_flag: bool = True) -> tuple[Any, ...]:
             for axl_ in ax1_.get_xticklabels(), ax1_.get_yticklabels():
                 plt.setp(axl_[::2], visible=False)
 
+            # Axis labels
+            if mktshare_axes_flag:
+                # x-axis
+                ax1_.set_xlabel("Firm 1 Market Share, $s_1$", fontsize=10)
+                ax1_.xaxis.set_label_coords(0.75, -0.1)
+                # y-axis
+                ax1_.set_ylabel("Firm 2 Market Share, $s_2$", fontsize=10)
+                ax1_.yaxis.set_label_coords(-0.1, 0.75)
+
         return ax1_
 
-    ax_out = _set_axis_def(ax_out, mktshares_plot_flag=mktshares_plot_flag)
+    ax_out = _set_axis_def(
+        ax_out,
+        mktshare_plot_flag=mktshare_plot_flag,
+        mktshare_axes_flag=mktshare_axes_flag,
+    )
 
     return plt, fig_, ax_out, _set_axis_def

{mergeron-2025.739290.6 → mergeron-2025.739290.7}/src/mergeron/core/guidelines_boundary_functions_extra.py

@@ -17,6 +17,7 @@ from scipy.spatial.distance import minkowski as distance_function  # type: ignor
 from sympy import lambdify, simplify, solve, symbols  # type: ignore
 
 from .. import DEFAULT_REC_RATIO, VERSION, ArrayDouble  # noqa: TID252
+from . import GuidelinesBoundary, MPFloat
 from . import guidelines_boundary_functions as gbf
 
 __version__ = VERSION
@@ -529,3 +530,209 @@ def shrratio_boundary_xact_avg_mp(  # noqa: PLR0914
     ) - mp.power(_s_mid, 2)
 
     return gbf.GuidelinesBoundary(bdry, float(mp.nstr(bdry_area_simpson, dps)))
+
+
+# shrratio_boundary_wtd_avg_autoroot
+# this function is about half as fast as the manual one! ... and a touch less precise
+def _shrratio_boundary_wtd_avg_autoroot(  # noqa: PLR0914
+    _delta_star: float = 0.075,
+    _r_val: float = DEFAULT_REC_RATIO,
+    /,
+    *,
+    agg_method: Literal[
+        "arithmetic mean", "geometric mean", "distance"
+    ] = "arithmetic mean",
+    weighting: Literal["own-share", "cross-product-share", None] = "own-share",
+    recapture_form: Literal["inside-out", "proportional"] = "inside-out",
+    dps: int = 5,
+) -> GuidelinesBoundary:
+    """
+    Share combinations on the share-weighted average diversion ratio boundary.
+
+    Parameters
+    ----------
+    _delta_star
+        Share ratio (:math:`\\overline{d} / \\overline{r}`)
+    _r_val
+        recapture ratio
+    agg_method
+        Whether "arithmetic mean", "geometric mean", or "distance".
+    weighting
+        Whether "own-share" or "cross-product-share"  (or None for simple, unweighted average).
+    recapture_form
+        Whether recapture-ratio is MNL-consistent ("inside-out") or has fixed
+        value for both merging firms ("proportional").
+    dps
+        Number of decimal places for rounding returned shares and area.
+
+    Returns
+    -------
+        Array of share-pairs, area under boundary.
+
+    Notes
+    -----
+    An analytical expression for the share-weighted arithmetic mean boundary
+    is derived and plotted from y-intercept to the ray of symmetry as follows::
+
+        from sympy import plot as symplot, solve, symbols
+        s_1, s_2 = symbols("s_1 s_2", positive=True)
+
+        g_val, r_val, m_val = 0.06, 0.80, 0.30
+        delta_star = g_val / (r_val * m_val)
+
+        # recapture_form == "inside-out"
+        oswag = solve(
+            s_1 * s_2 / (1 - s_1)
+            + s_2 * s_1 / (1 - (r_val * s_2 + (1 - r_val) * s_1))
+            - (s_1 + s_2) * delta_star,
+            s_2
+        )[0]
+        symplot(
+            oswag,
+            (s_1, 0., d_hat / (1 + d_hat)),
+            ylabel=s_2
+        )
+
+        cpswag = solve(
+            s_2 * s_2 / (1 - s_1)
+            + s_1 * s_1 / (1 - (r_val * s_2 + (1 - r_val) * s_1))
+            - (s_1 + s_2) * delta_star,
+            s_2
+        )[1]
+        symplot(
+            cpwag,
+            (s_1, 0.0, d_hat / (1 + d_hat)), ylabel=s_2
+        )
+
+        # recapture_form == "proportional"
+        oswag = solve(
+            s_1 * s_2 / (1 - s_1)
+            + s_2 * s_1 / (1 - s_2)
+            - (s_1 + s_2) * delta_star,
+             s_2
+        )[0]
+        symplot(
+            oswag,
+            (s_1, 0., d_hat / (1 + d_hat)),
+            ylabel=s_2
+        )
+
+        cpswag = solve(
+            s_2 * s_2 / (1 - s_1)
+            + s_1 * s_1 / (1 - s_2)
+            - (s_1 + s_2) * delta_star,
+             s_2
+        )[1]
+        symplot(
+            cpswag,
+            (s_1, 0.0, d_hat / (1 + d_hat)),
+            ylabel=s_2
+        )
+
+
+    """
+
+    _delta_star, _r_val = (mpf(f"{_v}") for _v in (_delta_star, _r_val))
+    _s_mid = mp.fdiv(_delta_star, 1 + _delta_star)
+
+    # initial conditions
+    bdry = [(_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, 0.0
+
+    # parameters for iteration
+    _step_size = mp.power(10, -dps)
+    theta_ = _step_size * (10 if weighting == "cross-product-share" else 1)
+    for s_1 in mp.arange(_s_mid - _step_size, 0, -_step_size):
+
+        def delta_test(x: MPFloat) -> MPFloat:
+            _de_1 = x / (1 - s_1)
+            _de_2 = (
+                s_1 / (1 - gbf.lerp(s_1, x, _r_val))
+                if recapture_form == "inside-out"
+                else s_1 / (1 - x)
+            )
+            _w = (
+                mp.fdiv(s_1 if weighting == "cross-product-share" else x, s_1 + x)
+                if weighting
+                else 0.5
+            )
+
+            match agg_method:
+                case "geometric mean":
+                    delta_test = mp.expm1(
+                        gbf.lerp(mp.log1p(_de_1), mp.log1p(_de_2), _w)
+                    )
+                case "distance":
+                    delta_test = mp.sqrt(gbf.lerp(_de_1**2, _de_2**2, _w))
+                case _:
+                    delta_test = gbf.lerp(_de_1, _de_2, _w)
+
+            return _delta_star - delta_test
+
+        try:
+            s_2 = mp.findroot(
+                delta_test,
+                x0=(s_2_pre * (1 - theta_), s_2_pre * (1 + theta_)),
+                tol=mp.sqrt(_step_size),
+                solver="ridder",
+            )
+        except (mp.ComplexResult, ValueError, ZeroDivisionError) as _e:
+            print(s_1, s_2_pre)
+            raise _e
+
+        # Build-up boundary points
+        bdry.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_1_pre + s_2_pre) > mpf("0.99875"):
+            # Loss of accuracy at 3-9s and up
+            break
+
+    if s_2_oddval:
+        s_2_evnsum -= s_2_pre
+    else:
+        s_2_oddsum -= s_1_pre
+
+    _s_intcpt = gbf._shrratio_boundary_intcpt(
+        s_2_pre,
+        _delta_star,
+        _r_val,
+        recapture_form=recapture_form,
+        agg_method=agg_method,
+        weighting=weighting,
+    )
+
+    if weighting == "own-share":
+        gbd_prtlarea = (
+            _step_size * (4 * s_2_oddsum + 2 * s_2_evnsum + _s_mid + s_2_pre) / 3
+        )
+        # Area under boundary
+        bdry_area_total = float(
+            2 * (s_1_pre + gbd_prtlarea)
+            - (mp.power(_s_mid, "2") + mp.power(s_1_pre, "2"))
+        )
+
+    else:
+        gbd_prtlarea = (
+            _step_size * (4 * s_2_oddsum + 2 * s_2_evnsum + _s_mid + _s_intcpt) / 3
+        )
+        # Area under boundary
+        bdry_area_total = float(2 * gbd_prtlarea - mp.power(_s_mid, "2"))
+
+    bdry.append((mpf("0.0"), _s_intcpt))
+    bdry_array = np.array(bdry, float)
+
+    # Points defining boundary to point-of-symmetry
+    return GuidelinesBoundary(
+        np.vstack((bdry_array[::-1], bdry_array[1:, ::-1]), dtype=float),
+        round(float(bdry_area_total), dps),
+    )

{mergeron-2025.739290.6 → mergeron-2025.739290.7}/src/mergeron/data/__init__.py

@@ -12,10 +12,9 @@ from .. import _PKG_NAME, VERSION  # noqa: TID252
 
 __version__ = VERSION
 
+data_resources = resources.files(f"{_PKG_NAME}.data")
 
-DAMODARAN_MARGIN_WORKBOOK = resources.files(f"{_PKG_NAME}.data").joinpath(
-    "damodaran_margin_data.xls"
-)
+DAMODARAN_MARGIN_WORKBOOK = data_resources / "damodaran_margin_data.xls"
 """
 Python object pointing to included copy of Prof. Damodaran's margin data
 
@@ -36,9 +35,7 @@ Use as, for example:
     shutil.copy2(DAMODARAN_MARGIN_WORKBOOK, Path.home() / f"{DAMODARAN_MARGIN_WORKBOOK.name}")
 """
 
-FTC_MERGER_INVESTIGATIONS_DATA = resources.files(f"{_PKG_NAME}.data").joinpath(
-    "ftc_merger_investigations_data.zip"
-)
+FTC_MERGER_INVESTIGATIONS_DATA = data_resources / "ftc_merger_investigations_data.zip"
 """
 FTC merger investigtions data published in 2004, 2007, 2008, and 2013
 
@@ -46,7 +43,7 @@ NOTES
 -----
 Raw data tables published by the FTC are loaded into a nested distionary, organized by
 data period, table type, and table number. Each table is stored as a numerical array
-(:module:`numpy` arrray), with additonal attrubutes for the industry group and additonal
+(:mod:`numpy` arrray), with additonal attrubutes for the industry group and additonal
 evidence noted in the source data.
 
 Data for additonal data periods (time spans) not reported in the  source data,

{mergeron-2025.739290.6 → mergeron-2025.739290.7}/src/mergeron/gen/__init__.py

@@ -13,7 +13,7 @@ from operator import attrgetter
 
 import h5py  # type: ignore
 import numpy as np
-from attrs import Attribute, Converter, cmp_using, field, frozen, validators
+from attrs import Attribute, Converter, cmp_using, field, frozen
 from numpy.random import SeedSequence
 
 from .. import (  # noqa: TID252
@@ -588,45 +588,39 @@ class INVResolution(str, Enameled):
 class UPPTestRegime:
     """Configuration for UPP tests."""
 
-    resolution: INVResolution = field(
-        kw_only=False,
-        default=INVResolution.ENFT,
-        validator=validators.in_([INVResolution.CLRN, INVResolution.ENFT]),
-    )
-    """Whether to test clearance, enforcement, or both."""
-
-    guppi_aggregator: UPPAggrSelector = field(
-        kw_only=False, default=UPPAggrSelector.MIN
-    )
-    """Aggregator for GUPPI test."""
-
-    divr_aggregator: UPPAggrSelector = field(kw_only=False, default=UPPAggrSelector.MIN)
-    """Aggregator for diversion ratio test."""
-
+    resolution: INVResolution = field(kw_only=False, default=INVResolution.ENFT)
+    """Whether to test clearance, enforcement."""
 
-@frozen
-class UPPTestsRaw:
-    """Container for arrays marking test failures and successes
-
-    A test success is a draw ("market") that meeets the
-    specified test criterion, and a test failure is
-    one that does not; test criteria are evaluated in
-    :func:`enforcement_stats.gen_upp_arrays`.
-    """
+    @resolution.validator
+    def _resvdtr(
+        _i: UPPTestRegime, _a: Attribute[INVResolution], _v: INVResolution
+    ) -> None:
+        if _v == INVResolution.BOTH:
+            raise ValueError(
+                "GUPPI test cannot be performed with both resolutions; only useful for reporting"
+            )
+        elif _v not in {INVResolution.CLRN, INVResolution.ENFT}:
+            raise ValueError(
+                f"Must be one of, {INVResolution.CLRN!r} or {INVResolution.ENFT!r}"
+            )
 
-    guppi_test_simple: ArrayBoolean
-    """True if GUPPI estimate meets criterion"""
+    guppi_aggregator: UPPAggrSelector = field(kw_only=False)
+    """Aggregator for GUPPI test."""
 
-    guppi_test_compound: ArrayBoolean
-    """True if both GUPPI estimate and diversion ratio estimate
-    meet criterion
-    """
+    @guppi_aggregator.default
+    def __gad(_i: UPPTestRegime) -> UPPAggrSelector:
+        return (
+            UPPAggrSelector.MIN
+            if _i.resolution == INVResolution.ENFT
+            else UPPAggrSelector.MAX
+        )
 
-    cmcr_test: ArrayBoolean
-    """True if CMCR estimate meets criterion"""
+    divr_aggregator: UPPAggrSelector = field(kw_only=False)
+    """Aggregator for diversion ratio test."""
 
-    ipr_test: ArrayBoolean
-    """True if IPR (partial price-simulation) estimate meets criterion"""
+    @divr_aggregator.default
+    def __dad(_i: UPPTestRegime) -> UPPAggrSelector:
+        return _i.guppi_aggregator
 
 
 @frozen

{mergeron-2025.739290.6 → mergeron-2025.739290.7}/src/mergeron/gen/data_generation.py

@@ -453,15 +453,6 @@ class MarketSample:
                 )
 
             if not _ndt:
-                # byte_stream = io.BytesIO()
-                # with h5py.File(byte_stream, "w") as h5f:
-                #     for _a in self.dataset.__attrs_attrs__:
-                #         if all((
-                #             (_arr := getattr(self.dataset, _a.name)).any(),
-                #             not np.isnan(_arr).all(),
-                #         )):
-                #             h5f.create_dataset(_a.name, data=_arr, fletcher32=True)
-
                 with (zpath / f"{name_root}_dataset.h5").open("wb") as _hfh:
                     _hfh.write(self.dataset.to_h5bin())
 
@@ -490,10 +481,7 @@ class MarketSample:
             if _dt:
                 with _dp.open("rb") as _hfh:
                     object.__setattr__(  # noqa: PLC2801
-                        market_sample_,
-                        "dataset",
-                        # MarketSampleData(**{_a: h5f[_a][:] for _a in h5f}),
-                        MarketSampleData.from_h5f(_hfh),
+                        market_sample_, "dataset", MarketSampleData.from_h5f(_hfh)
                     )
             if _et:
                 object.__setattr__(  # noqa: PLC2801

{mergeron-2025.739290.6 → mergeron-2025.739290.7}/src/mergeron/gen/enforcement_stats.py

@@ -7,7 +7,7 @@ import enum
 from collections.abc import Mapping
 
 import numpy as np
-from scipy.interpolate import interp1d  # type: ignore
+from scipy.interpolate import make_interp_spline  # type: ignore
 
 from .. import VERSION, ArrayBIGINT, Enameled, this_yaml  # noqa: TID252
 from ..core import ftc_merger_investigations_data as fid  # noqa: TID252
@@ -77,7 +77,7 @@ HHI_DELTA_KNOTS = np.array(
 )
 HHI_POST_ZONE_KNOTS = np.array([0, 1800, 2400, 10001], dtype=np.int64)
 hhi_delta_ranger, hhi_zone_post_ranger = (
-    interp1d(_f / 1e4, _f, kind="previous", assume_sorted=True)
+    make_interp_spline(_f / 1e4, _f, k=0)
     for _f in (HHI_DELTA_KNOTS, HHI_POST_ZONE_KNOTS)
 )
 
@@ -256,11 +256,16 @@ def table_no_lku(
 
 
 def enf_cnts_byfirmcount(_cnts_array: ArrayBIGINT, /) -> ArrayBIGINT:
+    if not _cnts_array[:, 0].any():
+        return np.array([], int)
+
     ndim_in = 1
     return np.vstack([
         np.concatenate([
             (_i,),
-            np.einsum("ij->j", _cnts_array[_cnts_array[:, 0] == _i][:, ndim_in:]),
+            np.einsum(
+                "ij->j", _cnts_array[_cnts_array[:, 0] == _i][:, ndim_in:], dtype=int
+            ),
         ])
         for _i in np.unique(_cnts_array[:, 0])
     ])
@@ -271,14 +276,16 @@ def enf_cnts_bydelta(_cnts_array: ArrayBIGINT, /) -> ArrayBIGINT:
     return np.vstack([
         np.concatenate([
             (_k,),
-            np.einsum("ij->j", _cnts_array[_cnts_array[:, 1] == _k][:, ndim_in:]),
+            np.einsum(
+                "ij->j", _cnts_array[_cnts_array[:, 1] == _k][:, ndim_in:], dtype=int
+            ),
         ])
         for _k in HHI_DELTA_KNOTS[:-1]
     ])
 
 
 def enf_cnts_byconczone(_cnts_array: ArrayBIGINT, /) -> ArrayBIGINT:
-    if not _cnts_array.any():
+    if not _cnts_array[:, 0].any() or np.isnan(_cnts_array[:, 0]).all():
         return np.array([], int)
     # Step 1: Tag and agg. from HHI-post and Delta to zone triple
     # NOTE: Although you could just map and not (partially) aggregate in this step,
@@ -315,7 +322,9 @@ def enf_cnts_byconczone(_cnts_array: ArrayBIGINT, /) -> ArrayBIGINT:
                 np.array(
                     (
                         *zone_val,
-                        *np.einsum("ij->j", _cnts_array[:, _ndim_in:][conc_test]),
+                        *np.einsum(
+                            "ij->j", _cnts_array[:, _ndim_in:][conc_test], dtype=int
+                        ),
                     ),
                     dtype=int,
                 ),
@@ -338,7 +347,9 @@ def enf_cnts_byconczone(_cnts_array: ArrayBIGINT, /) -> ArrayBIGINT:
                 (
                     zone_val,
                     np.einsum(
-                        "ij->j", cnts_byhhipostanddelta[hhi_zone_test][:, _nkeys:]
+                        "ij->j",
+                        cnts_byhhipostanddelta[hhi_zone_test][:, _nkeys:],
+                        dtype=int,
                     ),
                 ),
                 dtype=int,

{mergeron-2025.739290.6 → mergeron-2025.739290.7}/src/mergeron/gen/upp_tests.py

@@ -21,13 +21,7 @@ from .. import (  # noqa
     UPPAggrSelector,
 )
 from ..core import guidelines_boundaries as gbl  # noqa: TID252
-from . import (
-    INVResolution,
-    MarketSampleData,
-    UPPTestRegime,
-    UPPTestsCounts,
-    UPPTestsRaw,
-)
+from . import INVResolution, MarketSampleData, UPPTestRegime, UPPTestsCounts
 from . import enforcement_stats as esl
 
 __version__ = VERSION
@@ -41,7 +35,7 @@ class INVRESCntsArgs(TypedDict, total=False):
     nthreads: int
 
 
-def compute_upp_test_counts(
+def compute_upp_test_counts(  # noqa: PLR0914
     _market_data_sample: MarketSampleData,
     _upp_test_parms: gbl.HMGThresholds,
     _upp_test_regime: UPPTestRegime,
@@ -71,134 +65,6 @@ def compute_upp_test_counts(
 
     """
 
-    upp_test_arrays = compute_upp_test_arrays(
-        _market_data_sample, _upp_test_parms, _upp_test_regime
-    )
-
-    fcounts, hhi_delta, hhi_post = (
-        getattr(_market_data_sample, _g) for _g in ("fcounts", "hhi_delta", "hhi_post")
-    )
-
-    stats_rowlen = 6
-    # Clearance/enforcement counts --- by firm count
-    enf_cnts_sim_byfirmcount_array: ArrayBIGINT = np.zeros(stats_rowlen, int)
-    firmcounts_list = np.unique(fcounts)
-    if firmcounts_list.any():
-        for _fc in firmcounts_list:
-            fc_test = fcounts == _fc
-
-            enf_cnts_sim_byfirmcount_array = np.vstack((
-                enf_cnts_sim_byfirmcount_array,
-                np.array([
-                    _fc,
-                    np.einsum("ij->", 1 * fc_test),
-                    *[
-                        np.einsum(
-                            "ij->", 1 * (fc_test & getattr(upp_test_arrays, _a.name))
-                        )
-                        for _a in upp_test_arrays.__attrs_attrs__
-                    ],
-                ]),
-            ))
-
-        enf_cnts_sim_byfirmcount_array = enf_cnts_sim_byfirmcount_array[1:]
-    else:
-        enf_cnts_sim_byfirmcount_array = np.array([], int)
-
-    # Clearance/enforcement counts --- by delta
-    enf_cnts_sim_bydelta_array: ArrayBIGINT = np.zeros(stats_rowlen, int)
-    hhi_deltaranged = esl.hhi_delta_ranger(hhi_delta)
-    for hhi_deltalim in esl.HHI_DELTA_KNOTS[:-1]:
-        hhi_deltatest = hhi_deltaranged == hhi_deltalim
-
-        enf_cnts_sim_bydelta_array = np.vstack((
-            enf_cnts_sim_bydelta_array,
-            np.array([
-                hhi_deltalim,
-                np.einsum("ij->", 1 * hhi_deltatest),
-                *[
-                    np.einsum(
-                        "ij->", 1 * (hhi_deltatest & getattr(upp_test_arrays, _a.name))
-                    )
-                    for _a in upp_test_arrays.__attrs_attrs__
-                ],
-            ]),
-        ))
-
-    enf_cnts_sim_bydelta_array = enf_cnts_sim_bydelta_array[1:]
-
-    # Clearance/enforcement counts --- by zone
-    if np.isnan(hhi_post).all():
-        stats_byconczone_sim = np.array([], int)
-    else:
-        try:
-            hhi_zone_post_ranged = esl.hhi_zone_post_ranger(hhi_post)
-        except ValueError as _err:
-            print(hhi_post)
-            raise _err
-
-        stats_byconczone_sim = np.zeros(stats_rowlen + 1, int)
-        for hhi_zone_post_knot in esl.HHI_POST_ZONE_KNOTS[:-1]:
-            level_test = hhi_zone_post_ranged == hhi_zone_post_knot
-
-            for hhi_zone_delta_knot in [0, 100, 200]:
-                delta_test = (
-                    hhi_deltaranged > 100
-                    if hhi_zone_delta_knot == 200
-                    else hhi_deltaranged == hhi_zone_delta_knot
-                )
-
-                conc_test = level_test & delta_test
-
-                stats_byconczone_sim = np.vstack((
-                    stats_byconczone_sim,
-                    np.array([
-                        hhi_zone_post_knot,
-                        hhi_zone_delta_knot,
-                        np.einsum("ij->", 1 * conc_test),
-                        *[
-                            np.einsum(
-                                "ij->",
-                                1 * (conc_test & getattr(upp_test_arrays, _a.name)),
-                            )
-                            for _a in upp_test_arrays.__attrs_attrs__
-                        ],
-                    ]),
-                ))
-
-    enf_cnts_sim_byconczone_array = esl.enf_cnts_byconczone(stats_byconczone_sim[1:])
-
-    del stats_byconczone_sim
-    del hhi_delta, hhi_post, fcounts
-
-    return UPPTestsCounts(
-        enf_cnts_sim_byfirmcount_array,
-        enf_cnts_sim_bydelta_array,
-        enf_cnts_sim_byconczone_array,
-    )
-
-
-def compute_upp_test_arrays(
-    _market_data_sample: MarketSampleData,
-    _upp_test_parms: gbl.HMGThresholds,
-    _sim_test_regime: UPPTestRegime,
-    /,
-) -> UPPTestsRaw:
-    """
-    Generate UPP tests arrays for given configuration and market sample
-
-    Given a standards vector, market
-
-    Parameters
-    ----------
-    _market_data_sample
-        market data sample
-    _upp_test_parms
-        guidelines thresholds for testing UPP and related statistics
-    _sim_test_regime
-        configuration to use for generating UPP tests
-
-    """
     g_bar_, divr_bar_, cmcr_bar_, ipr_bar_ = (
         getattr(_upp_test_parms, _f) for _f in ("guppi", "divr", "cmcr", "ipr")
     )
@@ -228,32 +94,72 @@ def compute_upp_test_arrays(
     (divr_test_vector,) = _compute_test_array_seq(
         (_market_data_sample.divr_array,),
         _market_data_sample.frmshr_array,
-        _sim_test_regime.divr_aggregator,
+        _upp_test_regime.divr_aggregator,
     )
 
     (guppi_test_vector, cmcr_test_vector, ipr_test_vector) = _compute_test_array_seq(
         (guppi_array, cmcr_array, ipr_array),
         _market_data_sample.frmshr_array,
-        _sim_test_regime.guppi_aggregator,
+        _upp_test_regime.guppi_aggregator,
     )
     del cmcr_array, ipr_array, guppi_array
 
-    if _sim_test_regime.resolution == INVResolution.ENFT:
-        upp_test_arrays = UPPTestsRaw(
+    if _upp_test_regime.resolution == INVResolution.ENFT:
+        upp_test_arrays = np.hstack((
             guppi_test_vector >= g_bar_,
             (guppi_test_vector >= g_bar_) | (divr_test_vector >= divr_bar_),
             cmcr_test_vector >= cmcr_bar_,
             ipr_test_vector >= ipr_bar_,
-        )
+        ))
     else:
-        upp_test_arrays = UPPTestsRaw(
+        upp_test_arrays = np.hstack((
             guppi_test_vector < g_bar_,
             (guppi_test_vector < g_bar_) & (divr_test_vector < divr_bar_),
             cmcr_test_vector < cmcr_bar_,
             ipr_test_vector < ipr_bar_,
-        )
+        ))
+
+    fcounts, hhi_delta, hhi_post = (
+        getattr(_market_data_sample, _g) for _g in ("fcounts", "hhi_delta", "hhi_post")
+    )
 
-    return upp_test_arrays
+    # Clearance counts by firm count
+    enf_cnts_sim_byfirmcount_array = esl.enf_cnts_byfirmcount(
+        np.hstack((fcounts, np.ones_like(fcounts), upp_test_arrays))
+    )
+
+    # Clearance counts by Delta and Concentration Zone
+    hhi_zone_ranged = (
+        esl.hhi_zone_post_ranger(hhi_post).astype(int)
+        if hhi_post.any() and not np.isnan(hhi_post).all()
+        else np.zeros_like(hhi_post, int)
+    )
+    hhi_delta_ranged = esl.hhi_delta_ranger(hhi_delta).astype(int)
+
+    enf_cnts_sim_byhhianddelta_array = np.hstack(
+        (
+            hhi_zone_ranged,
+            hhi_delta_ranged,
+            np.ones_like(hhi_delta_ranged),
+            upp_test_arrays,
+            # *[
+            #     1 * getattr(upp_test_arrays, _a.name)
+            #     for _a in upp_test_arrays.__attrs_attrs__
+            # ],
+        ),
+        dtype=int,
+    )
+
+    enf_cnts_sim_bydelta_array = esl.enf_cnts_bydelta(enf_cnts_sim_byhhianddelta_array)
+    enf_cnts_sim_byconczone_array = esl.enf_cnts_byconczone(
+        enf_cnts_sim_byhhianddelta_array
+    )
+
+    return UPPTestsCounts(
+        enf_cnts_sim_byfirmcount_array,
+        enf_cnts_sim_bydelta_array,
+        enf_cnts_sim_byconczone_array,
+    )
 
 
 def _compute_test_array_seq(