mergeron 2024.739099.2__py3-none-any.whl → 2024.739104.1__py3-none-any.whl

mergeron/gen/{_data_generation_functions.py → data_generation_functions.py}

@@ -4,13 +4,14 @@ Non-public functions called in data_generation.py
 
 from __future__ import annotations
 
+from collections.abc import Sequence
 from typing import Literal
 
 import numpy as np
 from attrs import evolve
 from numpy.random import SeedSequence
 
-from .. import VERSION, ArrayBIGINT, ArrayDouble, RECConstants  # noqa: TID252
+from .. import VERSION, ArrayBIGINT, ArrayDouble, RECTypes  # noqa: TID252
 from ..core.damodaran_margin_data import mgn_data_resampler  # noqa: TID252
 from ..core.pseudorandom_numbers import (  # noqa: TID252
     DIST_PARMS_DEFAULT,
@@ -18,23 +19,25 @@ from ..core.pseudorandom_numbers import (  # noqa: TID252
     prng,
 )
 from . import (
+    EMPTY_ARRAY_DEFAULT,
     FCOUNT_WTS_DEFAULT,
     FM2Constants,
     MarginDataSample,
-    PCMConstants,
+    PCMDistributions,
     PCMSpec,
-    PriceConstants,
     PriceDataSample,
+    PriceSpec,
+    SeedSequenceData,
     ShareDataSample,
     ShareSpec,
-    SHRConstants,
+    SHRDistributions,
     SSZConstants,
 )
 
 __version__ = VERSION
 
 
-def _gen_share_data(
+def gen_share_data(
     _sample_size: int,
     _share_spec: ShareSpec,
     _fcount_rng_seed_seq: SeedSequence | None,
@@ -68,8 +71,8 @@ def _gen_share_data(
 
     _ssz = _sample_size
 
-    if _dist_type_mktshr == SHRConstants.UNI:
-        _mkt_share_sample = _gen_market_shares_uniform(
+    if _dist_type_mktshr == SHRDistributions.UNI:
+        _mkt_share_sample = gen_market_shares_uniform(
             _ssz, _dist_parms_mktshr, _mktshr_rng_seed_seq, _nthreads
         )
 
@@ -79,7 +82,7 @@ def _gen_share_data(
             if _firm_count_prob_wts is None
             else np.array(_firm_count_prob_wts, dtype=np.float64)
         )
-        _mkt_share_sample = _gen_market_shares_dirichlet_multisample(
+        _mkt_share_sample = gen_market_shares_dirichlet_multimarket(
             _ssz,
             _recapture_form,
             _dist_type_mktshr,
@@ -97,8 +100,8 @@ def _gen_share_data(
 
     # If recapture_form == "inside-out", recalculate _aggregate_purchase_prob
     _frmshr_array = _mkt_share_sample.mktshr_array[:, :2]
-    _r_bar = _share_spec.recapture_rate or 0.85
-    if _recapture_form == RECConstants.INOUT:
+    _r_bar = _share_spec.recapture_rate or 0.8
+    if _recapture_form == RECTypes.INOUT:
         _mkt_share_sample = ShareDataSample(
             _mkt_share_sample.mktshr_array,
             _mkt_share_sample.fcounts,
@@ -109,7 +112,7 @@ def _gen_share_data(
     return _mkt_share_sample
 
 
-def _gen_market_shares_uniform(
+def gen_market_shares_uniform(
     _s_size: int = 10**6,
     _dist_parms_mktshr: ArrayDouble | None = DIST_PARMS_DEFAULT,
     _mktshr_rng_seed_seq: SeedSequence | None = None,
@@ -122,10 +125,10 @@ def _gen_market_shares_uniform(
     ----------
     _s_size
         size of sample to be drawn
-    _r_bar
-        market recapture rate
+
     _mktshr_rng_seed_seq
         seed for rng, so results can be made replicable
+
     _nthreads
         number of threads for random number generation
 
@@ -172,10 +175,10 @@ def _gen_market_shares_uniform(
     )
 
 
-def _gen_market_shares_dirichlet_multisample(
+def gen_market_shares_dirichlet_multimarket(
     _s_size: int = 10**6,
-    _recapture_form: RECConstants = RECConstants.INOUT,
-    _dist_type_dir: SHRConstants = SHRConstants.DIR_FLAT,
+    _recapture_form: RECTypes = RECTypes.INOUT,
+    _dist_type_dir: SHRDistributions = SHRDistributions.DIR_FLAT,
     _dist_parms_dir: ArrayDouble | None = None,
     _firm_count_wts: ArrayDouble | None = None,
     _fcount_rng_seed_seq: SeedSequence | None = None,
@@ -194,18 +197,22 @@ def _gen_market_shares_dirichlet_multisample(
     ----------
     _s_size
         sample size to be drawn
-    _r_bar
-        market recapture rate
+
     _firm_count_wts
         firm count weights array for sample to be drawn
+
     _dist_type_dir
         Whether Dirichlet is Flat or Asymmetric
+
     _recapture_form
         r_1 = r_2 if "proportional", otherwise MNL-consistent
+
     _fcount_rng_seed_seq
         seed firm count rng, for replicable results
+
     _mktshr_rng_seed_seq
         seed market share rng, for replicable results
+
     _nthreads
         number of threads for parallelized random number generation
 
@@ -219,7 +226,9 @@ def _gen_market_shares_dirichlet_multisample(
         FCOUNT_WTS_DEFAULT if _firm_count_wts is None else _firm_count_wts
     )
 
-    _min_choice_wt = 0.03 if _dist_type_dir == SHRConstants.DIR_FLAT_CONSTR else 0.00
+    _min_choice_wt = (
+        0.03 if _dist_type_dir == SHRDistributions.DIR_FLAT_CONSTR else 0.00
+    )
     _fcount_keys, _choice_wts = zip(
         *(
             _f
@@ -237,10 +246,10 @@ def _gen_market_shares_dirichlet_multisample(
     _dir_alphas_full = (
         [1.0] * _fc_max if _dist_parms_dir is None else _dist_parms_dir[:_fc_max]
     )
-    if _dist_type_dir == SHRConstants.DIR_ASYM:
+    if _dist_type_dir == SHRDistributions.DIR_ASYM:
         _dir_alphas_full = [2.0] * 6 + [1.5] * 5 + [1.25] * min(7, _fc_max)
 
-    if _dist_type_dir == SHRConstants.DIR_COND:
+    if _dist_type_dir == SHRDistributions.DIR_COND:
 
         def _gen_dir_alphas(_fcv: int) -> ArrayDouble:
             _dat = [2.5] * 2
@@ -272,7 +281,7 @@ def _gen_market_shares_dirichlet_multisample(
         _dir_alphas_test = _gen_dir_alphas(_f_val)
 
         try:
-            _mktshr_sample_f = _gen_market_shares_dirichlet(
+            _mktshr_sample_f = gen_market_shares_dirichlet(
                 _dir_alphas_test,
                 len(_fcounts_match_rows),
                 _recapture_form,
@@ -310,10 +319,10 @@ def _gen_market_shares_dirichlet_multisample(
     )
 
 
-def _gen_market_shares_dirichlet(
+def gen_market_shares_dirichlet(
     _dir_alphas: ArrayDouble,
     _s_size: int = 10**6,
-    _recapture_form: RECConstants = RECConstants.INOUT,
+    _recapture_form: RECTypes = RECTypes.INOUT,
     _mktshr_rng_seed_seq: SeedSequence | None = None,
     _nthreads: int = 16,
     /,
@@ -324,16 +333,18 @@ def _gen_market_shares_dirichlet(
     ----------
     _dir_alphas
         Shape parameters for Dirichlet distribution
+
     _s_size
         sample size to be drawn
-    _r_bar
-        market recapture rate
+
     _recapture_form
-        r_1 = r_2 if RECConstants.FIXED, otherwise MNL-consistent. If
-        RECConstants.OUTIN; the number of columns in the output share array
+        r_1 = r_2 if RECTypes.FIXED, otherwise MNL-consistent. If
+        RECTypes.OUTIN; the number of columns in the output share array
         is len(_dir_alphas) - 1.
+
     _mktshr_rng_seed_seq
         seed market share rng, for replicable results
+
     _nthreads
         number of threads for parallelized random number generation
 
@@ -346,7 +357,7 @@ def _gen_market_shares_dirichlet(
     if not isinstance(_dir_alphas, np.ndarray):
         _dir_alphas = np.array(_dir_alphas)
 
-    if _recapture_form == RECConstants.OUTIN:
+    if _recapture_form == RECTypes.OUTIN:
         _dir_alphas = np.concatenate((_dir_alphas, _dir_alphas[-1:]))
 
     _mktshr_seed_seq_ch = (
@@ -380,7 +391,7 @@ def _gen_market_shares_dirichlet(
 
     # If recapture_form == 'inside_out', further calculations downstream
     _aggregate_purchase_prob = np.nan * np.empty((_s_size, 1))
-    if _recapture_form == RECConstants.OUTIN:
+    if _recapture_form == RECTypes.OUTIN:
         _aggregate_purchase_prob = 1 - _mktshr_array[:, [-1]]
         _mktshr_array = _mktshr_array[:, :-1] / _aggregate_purchase_prob
 
@@ -392,18 +403,124 @@ def _gen_market_shares_dirichlet(
     )
 
 
-def _gen_margin_price_data(
+def gen_divr_array(
+    _recapture_form: RECTypes,
+    _recapture_rate: float | None,
+    _frmshr_array: ArrayDouble,
+    _aggregate_purchase_prob: ArrayDouble = EMPTY_ARRAY_DEFAULT,
+    /,
+) -> ArrayDouble:
+    """
+    Given merging-firm shares and related parameters, return diverion ratios.
+
+    If recapture is specified as :attr:`mergeron.RECTypes.OUTIN`, then the
+    choice-probability for the outside good must be supplied.
+
+    Parameters
+    ----------
+    _recapture_form
+        Enum specifying Fixed (proportional), Inside-out, or Outside-in
+
+    _recapture_rate
+        If recapture is proportional or inside-out, the recapture rate
+        for the firm with the smaller share.
+
+    _frmshr_array
+        Merging-firm shares.
+
+    _aggregate_purchase_prob
+        1 minus probability that the outside good is chosen; converts
+        market shares to choice probabilities by multiplication.
+
+    Raises
+    ------
+    ValueError
+        If the firm with the smaller share does not have the larger
+        diversion ratio between the merging firms.
+
+    Returns
+    -------
+        Merging-firm diversion ratios for mergers in the sample.
+
+    """
+
+    _divr_array: ArrayDouble
+    if _recapture_form == RECTypes.FIXED:
+        _divr_array = _recapture_rate * _frmshr_array[:, ::-1] / (1 - _frmshr_array)  # type: ignore
+
+    else:
+        _purchprob_array = _aggregate_purchase_prob * _frmshr_array
+        _divr_array = _purchprob_array[:, ::-1] / (1 - _purchprob_array)
+
+    _divr_assert_test = (
+        (np.round(np.einsum("ij->i", _frmshr_array), 15) == 1)
+        | (np.argmin(_frmshr_array, axis=1) == np.argmax(_divr_array, axis=1))
+    )[:, None]
+    if not all(_divr_assert_test):
+        raise ValueError(
+            "{} {} {} {}".format(
+                "Data construction fails tests:",
+                "the index of min(s_1, s_2) must equal",
+                "the index of max(d_12, d_21), for all draws.",
+                "unless frmshr_array sums to 1.00.",
+            )
+        )
+
+    return _divr_array
+
+
+def gen_margin_price_data(
     _frmshr_array: ArrayDouble,
     _nth_firm_share: ArrayDouble,
     _aggregate_purchase_prob: ArrayDouble,
     _pcm_spec: PCMSpec,
-    _price_spec: PriceConstants,
+    _price_spec: PriceSpec,
     _hsr_filing_test_type: SSZConstants,
     _pcm_rng_seed_seq: SeedSequence,
     _pr_rng_seed_seq: SeedSequence | None = None,
     _nthreads: int = 16,
     /,
 ) -> tuple[MarginDataSample, PriceDataSample]:
+    """Generate margin and price data for mergers in the sample.
+
+    Parameters
+    ----------
+    _frmshr_array
+        Merging-firm shares; see :class:`mergeron.gen.ShareSpec`.
+
+    _nth_firm_share
+        Share of the nth firm in the sample.
+
+    _aggregate_purchase_prob
+        1 minus probability that the outside good is chosen; converts
+        market shares to choice probabilities by multiplication.
+
+    _pcm_spec
+        Enum specifying whether to use asymmetric or flat margins. see
+        :class:`mergeron.gen.PCMSpec`.
+
+    _price_spec
+        Enum specifying whether to use symmetric, positive, or negative
+        margins; see :class:`mergeron.gen.PriceSpec`.
+
+    _hsr_filing_test_type
+        Enum specifying restriction, if any, to impose on market data sample
+        to model HSR filing requirements; see :class:`mergeron.gen.SSZConstants`.
+
+    _pcm_rng_seed_seq
+        Seed sequence for generating margin data.
+
+    _pr_rng_seed_seq
+        Seed sequence for generating price data.
+
+    _nthreads
+        Number of threads to use in generating price data.
+
+    Returns
+    -------
+        Simulated margin- and price-data arrays for mergers in the sample.
+    """
+
     _price_array, _price_ratio_array = (
         np.ones_like(_frmshr_array, np.float64),
         np.empty_like(_frmshr_array, np.float64),
@@ -411,25 +528,25 @@ def _gen_margin_price_data(
 
     _pr_max_ratio = 5.0
     match _price_spec:
-        case PriceConstants.SYM:
+        case PriceSpec.SYM:
             _nth_firm_price = np.ones((len(_frmshr_array), 1))
-        case PriceConstants.POS:
+        case PriceSpec.POS:
             _price_array, _nth_firm_price = (
                 np.ceil(_p * _pr_max_ratio) for _p in (_frmshr_array, _nth_firm_share)
             )
-        case PriceConstants.NEG:
+        case PriceSpec.NEG:
             _price_array, _nth_firm_price = (
                 np.ceil((1 - _p) * _pr_max_ratio)
                 for _p in (_frmshr_array, _nth_firm_share)
             )
-        case PriceConstants.ZERO:
+        case PriceSpec.ZERO:
             _price_array_gen = prng(_pr_rng_seed_seq).choice(
                 1 + np.arange(_pr_max_ratio), size=(len(_frmshr_array), 3)
             )
             _price_array = _price_array_gen[:, :2]
             _nth_firm_price = _price_array_gen[:, [2]]
             # del _price_array_gen
-        case PriceConstants.CSY:
+        case PriceSpec.CSY:
             # TODO:
             # evolve FM2Constraint (save running MNL test twice); evolve copy of _mkt_sample_spec=1q
             # generate the margin data
@@ -479,7 +596,7 @@ def _gen_margin_price_data(
                 f"Specitication of price distribution"
                 f' "{_price_spec.value}" is invalid.'
             )
-    if _price_spec != PriceConstants.CSY:
+    if _price_spec != PriceSpec.CSY:
         _margin_data = _gen_margin_data(
             _frmshr_array,
             _price_array,
@@ -535,94 +652,6 @@ def _gen_margin_price_data(
     return _margin_data, PriceDataSample(_price_array, _hsr_filing_test)
 
 
-# marked for deletion
-def _gen_price_data(
-    _frmshr_array: ArrayDouble,
-    _nth_firm_share: ArrayDouble,
-    _price_spec: PriceConstants,
-    _hsr_filing_test_type: SSZConstants,
-    _seed_seq: SeedSequence | None = None,
-    /,
-) -> PriceDataSample:
-    _price_array, _price_ratio_array, _hsr_filing_test = (
-        np.ones_like(_frmshr_array, np.float64),
-        np.empty_like(_frmshr_array, np.float64),
-        np.empty(len(_frmshr_array), bool),
-    )
-
-    _pr_max_ratio = 5.0
-    match _price_spec:
-        case PriceConstants.SYM:
-            _nth_firm_price = np.ones((len(_frmshr_array), 1))
-        case PriceConstants.POS:
-            _price_array, _nth_firm_price = (
-                np.ceil(_p * _pr_max_ratio) for _p in (_frmshr_array, _nth_firm_share)
-            )
-        case PriceConstants.NEG:
-            _price_array, _nth_firm_price = (
-                np.ceil((1 - _p) * _pr_max_ratio)
-                for _p in (_frmshr_array, _nth_firm_share)
-            )
-        case PriceConstants.ZERO:
-            _price_array_gen = prng(_seed_seq).choice(
-                1 + np.arange(_pr_max_ratio), size=(len(_frmshr_array), 3)
-            )
-            _price_array = _price_array_gen[:, :2]
-            _nth_firm_price = _price_array_gen[:, [2]]
-            # del _price_array_gen
-        case PriceConstants.CSY:
-            raise ValueError("Market-wide cost-symmetry is not yet implemented.")
-        case _:
-            raise ValueError(
-                f"Specitication of price distribution"
-                f' "{_price_spec.value}" is invalid.'
-            )
-
-    _price_array = _price_array.astype(np.float64)
-    _rev_array = _price_array * _frmshr_array
-    _nth_firm_rev = _nth_firm_price * _nth_firm_share
-
-    # Although `_test_rev_ratio_inv` is not fixed at 10%,
-    # the ratio has not changed since inception of the HSR filing test,
-    # so we treat it as a constant of merger enforcement policy.
-    _test_rev_ratio, _test_rev_ratio_inv = 10, 1 / 10
-
-    match _hsr_filing_test_type:
-        case SSZConstants.HSR_TEN:
-            # See, https://www.ftc.gov/enforcement/premerger-notification-program/
-            #   -> Procedures For Submitting Post-Consummation Filings
-            #    -> Key Elements to Determine Whether a Post Consummation Filing is Required
-            #           under heading, "Historical Thresholds"
-            # Revenue ratio has been 10-to-1 since inception
-            # Thus, a simple form of the HSR filing test would impose a 10-to-1
-            # ratio restriction on the merging firms' revenues
-            _rev_ratio = (_rev_array.min(axis=1) / _rev_array.max(axis=1)).round(4)
-            _hsr_filing_test = _rev_ratio >= _test_rev_ratio_inv
-            # del _rev_array, _rev_ratio
-        case SSZConstants.HSR_NTH:
-            # To get around the 10-to-1 ratio restriction, specify that the nth firm test:
-            # if the smaller merging firm matches or exceeds the n-th firm in size, and
-            # the larger merging firm has at least 10 times the size of the nth firm,
-            # the size test is considered met.
-            # Alternatively, if the smaller merging firm has 10% or greater share,
-            # the value of transaction test is considered met.
-            _rev_ratio_to_nth = np.round(np.sort(_rev_array, axis=1) / _nth_firm_rev, 4)
-            _hsr_filing_test = (
-                np.einsum(
-                    "ij->i",
-                    1 * (_rev_ratio_to_nth > [1, _test_rev_ratio]),
-                    dtype=np.int64,
-                )
-                == _rev_ratio_to_nth.shape[1]
-            ) | (_frmshr_array.min(axis=1) >= _test_rev_ratio_inv)
-
-        case _:
-            # Otherwise, all draws meet the filing test
-            _hsr_filing_test = np.ones(len(_frmshr_array), dtype=bool)
-
-    return PriceDataSample(_price_array, _hsr_filing_test)
-
-
 def _gen_margin_data(
     _frmshr_array: ArrayDouble,
     _price_array: ArrayDouble,
@@ -645,23 +674,23 @@ def _gen_margin_data(
     )
 
     _beta_min, _beta_max = [None] * 2  # placeholder
-    if _dist_type_pcm == PCMConstants.EMPR:
+    if _dist_type_pcm == PCMDistributions.EMPR:
         _pcm_array = mgn_data_resampler(
             _pcm_array.shape,  # type: ignore
             seed_sequence=_pcm_rng_seed_seq,
         )
     else:
-        _dist_type = "Uniform" if _dist_type_pcm == PCMConstants.UNI else "Beta"
-        if _dist_type_pcm == PCMConstants.BETA:
+        _dist_type = "Uniform" if _dist_type_pcm == PCMDistributions.UNI else "Beta"
+        if _dist_type_pcm == PCMDistributions.BETA:
             if _dist_parms_pcm is None:
                 _dist_parms_pcm = np.ones(2, np.float64)
 
-        elif _dist_type_pcm == PCMConstants.BETA_BND:  # Bounded beta
+        elif _dist_type_pcm == PCMDistributions.BETA_BND:  # Bounded beta
             if _dist_parms_pcm is None:
                 _dist_parms_pcm = np.array([0, 1, 0, 1], np.float64)
                 _dist_parms = beta_located_bound(_dist_parms_pcm)
         else:
-            #  _dist_type_pcm == PCMConstants.UNI
+            #  _dist_type_pcm == PCMDistributions.UNI
             _dist_parms = (
                 DIST_PARMS_DEFAULT if _dist_parms_pcm is None else _dist_parms_pcm
             )
@@ -676,7 +705,7 @@ def _gen_margin_data(
         _pcm_rng.fill()
         del _pcm_rng
 
-    if _dist_type_pcm == PCMConstants.BETA_BND:
+    if _dist_type_pcm == PCMDistributions.BETA_BND:
         _beta_min, _beta_max = _dist_parms_pcm[2:]
         _pcm_array = (_beta_max - _beta_min) * _pcm_array + _beta_min
         del _beta_min, _beta_max
@@ -685,7 +714,7 @@ def _gen_margin_data(
         _pcm_array = np.column_stack((_pcm_array,) * _frmshr_array.shape[1])
     if _dist_firm2_pcm == FM2Constants.MNL:
         # Impose FOCs from profit-maximization with MNL demand
-        if _dist_type_pcm == PCMConstants.EMPR:
+        if _dist_type_pcm == PCMDistributions.EMPR:
             print(
                 "NOTE: Estimated Firm 2 parameters will not be consistent with "
                 "the empirical distribution of margins in the source data. For "
@@ -767,3 +796,65 @@ def beta_located_bound(_dist_parms: ArrayDouble, /) -> ArrayDouble:
 
     _bmu, _bsigma, _bmin, _bmax = _dist_parms
     return _beta_located((_bmu - _bmin) / (_bmax - _bmin), _bsigma / (_bmax - _bmin))
+
+
+def parse_seed_seq_list(
+    _sseq_list: Sequence[SeedSequence] | None,
+    _mktshr_dist_type: SHRDistributions,
+    _price_spec: PriceSpec,
+    /,
+) -> SeedSequenceData:
+    """Initialize RNG seed sequences to ensure independence of distinct random streams.
+
+    The tuple of SeedSequences, is parsed in the following order
+    for generating the relevant random variates:
+    1.) quantity shares
+    2.) price-cost margins
+    3.) firm-counts, if :code:`MarketSpec.share_spec.dist_type` is a Dirichlet distribution
+    4.) prices, if :code:`MarketSpec.price_spec ==`:attr:`mergeron.gen.PriceSpec.ZERO`.
+
+
+
+    Parameters
+    ----------
+    _sseq_list
+        List of RNG seed sequences
+
+    _mktshr_dist_type
+        Market share distribution type
+
+    _price_spec
+        Price specification
+
+    Returns
+    -------
+        Seed sequence data
+
+    """
+    _fcount_rng_seed_seq: SeedSequence | None = None
+    _pr_rng_seed_seq: SeedSequence | None = None
+
+    if _price_spec == PriceSpec.ZERO:
+        _sseq_list, _pr_rng_seed_seq = (
+            (_sseq_list[:-1], _sseq_list[-1])
+            if _sseq_list
+            else (None, SeedSequence(pool_size=8))
+        )
+
+    _seed_count = 2 if _mktshr_dist_type == SHRDistributions.UNI else 3
+
+    if _sseq_list:
+        if len(_sseq_list) < _seed_count:
+            raise ValueError(
+                f"seed sequence list must contain {_seed_count} seed sequences"
+            )
+    else:
+        _sseq_list = tuple(SeedSequence(pool_size=8) for _ in range(_seed_count))
+
+    (_mktshr_rng_seed_seq, _pcm_rng_seed_seq, _fcount_rng_seed_seq) = (
+        _sseq_list if _seed_count == 3 else (*_sseq_list, None)  # type: ignore
+    )
+
+    return SeedSequenceData(
+        _mktshr_rng_seed_seq, _pcm_rng_seed_seq, _fcount_rng_seed_seq, _pr_rng_seed_seq
+    )

mergeron/gen/enforcement_stats.py

@@ -21,7 +21,6 @@ from scipy.stats import beta, norm  # type: ignore
 from .. import (  # noqa: TID252
     _PKG_NAME,
     DATA_DIR,
-    TI,
     VERSION,
     ArrayBIGINT,
     ArrayDouble,
@@ -165,32 +164,6 @@ hhi_delta_ranger, hhi_zone_post_ranger = (
     for _f in (HHI_DELTA_KNOTS, HHI_POST_ZONE_KNOTS)
 )
 
-HMG_PRESUMPTION_ZONE_DICT = {
-    HHI_POST_ZONE_KNOTS[0]: {
-        HHI_DELTA_KNOTS[0]: (0, 0, 0),
-        HHI_DELTA_KNOTS[1]: (0, 0, 0),
-        HHI_DELTA_KNOTS[2]: (0, 0, 0),
-    },
-    HHI_POST_ZONE_KNOTS[1]: {
-        HHI_DELTA_KNOTS[0]: (0, 1, 1),
-        HHI_DELTA_KNOTS[1]: (1, 1, 2),
-        HHI_DELTA_KNOTS[2]: (1, 1, 2),
-    },
-    HHI_POST_ZONE_KNOTS[2]: {
-        HHI_DELTA_KNOTS[0]: (0, 2, 1),
-        HHI_DELTA_KNOTS[1]: (1, 2, 3),
-        HHI_DELTA_KNOTS[2]: (2, 2, 4),
-    },
-}
-
-ZONE_VALS = np.unique(
-    np.vstack([
-        tuple(HMG_PRESUMPTION_ZONE_DICT[_k].values())
-        for _k in HMG_PRESUMPTION_ZONE_DICT
-    ]),
-    axis=0,
-)
-
 ZONE_STRINGS = {
     0: R"Green Zone (Safeharbor)",
     1: R"Yellow Zone",
@@ -234,6 +207,31 @@ ZONE_DETAIL_STRINGS_DELTA_LATEX = {
     4: Rf"\Delta HHI \geqslant \text{{{HHI_DELTA_KNOTS[2]} pts.}}",
 }
 
+HMG_PRESUMPTION_ZONE_MAP = {
+    HHI_POST_ZONE_KNOTS[0]: {
+        HHI_DELTA_KNOTS[0]: (0, 0, 0),
+        HHI_DELTA_KNOTS[1]: (0, 0, 0),
+        HHI_DELTA_KNOTS[2]: (0, 0, 0),
+    },
+    HHI_POST_ZONE_KNOTS[1]: {
+        HHI_DELTA_KNOTS[0]: (0, 1, 1),
+        HHI_DELTA_KNOTS[1]: (1, 1, 2),
+        HHI_DELTA_KNOTS[2]: (1, 1, 2),
+    },
+    HHI_POST_ZONE_KNOTS[2]: {
+        HHI_DELTA_KNOTS[0]: (0, 2, 1),
+        HHI_DELTA_KNOTS[1]: (1, 2, 3),
+        HHI_DELTA_KNOTS[2]: (2, 2, 4),
+    },
+}
+
+ZONE_VALS = np.unique(
+    np.vstack([
+        tuple(HMG_PRESUMPTION_ZONE_MAP[_k].values()) for _k in HMG_PRESUMPTION_ZONE_MAP
+    ]),
+    axis=0,
+)
+
 
 def enf_stats_output(
     _data_array_dict: fid.INVData,
@@ -475,7 +473,7 @@ def enf_cnts_byconczone(_cnts_array: ArrayBIGINT, /) -> ArrayBIGINT:
                 else (_hhi_delta_ranged == _hhi_zone_delta_lim)
             )
 
-            _zone_val = HMG_PRESUMPTION_ZONE_DICT[_hhi_zone_post_lim][
+            _zone_val = HMG_PRESUMPTION_ZONE_MAP[_hhi_zone_post_lim][
                 _hhi_zone_delta_lim
             ]
 
@@ -723,8 +721,8 @@ def stats_print_rows(
 
 
 def propn_ci(
-    _npos: ArrayINT[TI] | int = 4,
-    _nobs: ArrayINT[TI] | int = 10,
+    _npos: ArrayINT | int = 4,
+    _nobs: ArrayINT | int = 10,
     /,
     *,
     alpha: float = 0.05,