mergeron 2025.739290.7__tar.gz → 2025.739290.9__tar.gz

mergeron-2025.739290.9/PKG-INFO

@@ -0,0 +1,178 @@
+Metadata-Version: 2.3
+Name: mergeron
+Version: 2025.739290.9
+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
+Author: Murthy Kambhampaty
+Author-email: smk@capeconomics.com
+Requires-Python: >=3.12,<4.0
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Requires-Dist: aenum (>=3.1.15,<4.0.0)
+Requires-Dist: attrs (>=23.2)
+Requires-Dist: bs4 (>=0.0.1)
+Requires-Dist: certifi (>=2023.11.17)
+Requires-Dist: h5py (>=3.13.0,<4.0.0)
+Requires-Dist: jinja2 (>=3.1)
+Requires-Dist: joblib (>=1.3)
+Requires-Dist: matplotlib (>=3.8)
+Requires-Dist: mpmath (>=1.3)
+Requires-Dist: msgpack (>=1.0)
+Requires-Dist: msgpack-numpy (>=0.4)
+Requires-Dist: ruamel-yaml (>=0.18.10,<0.19.0)
+Requires-Dist: scipy (>=1.12)
+Requires-Dist: sympy (>=1.12)
+Requires-Dist: types-beautifulsoup4 (>=4.11.2)
+Requires-Dist: urllib3 (>=2.2.2,<3.0.0)
+Requires-Dist: xlrd (>=2.0.1,<3.0.0)
+Requires-Dist: xlsxwriter (>=3.1)
+Description-Content-Type: text/x-rst
+
+mergeron: Merger Policy Analysis with Python
+============================================
+
+Usage
+-----
+
+*Visualizing Guidelines boundaries*
+
+.. code:: python
+
+    %matplotlib inline
+    from mergeron.core import guidelines_boundaries as gbl
+    from mergeron.core import guidelines_boundary_functions as gbf
+    from math import sqrt
+
+    delta_bound = 0.01
+    conc_boundary = gbl.ConcentrationBoundary(delta_bound, "ΔHHI")
+    share_boundary = gbl.ConcentrationBoundary(2 * sqrt(delta_bound / 2), "Combined share")
+
+    divr_boundary_a = gbl.DiversionRatioBoundary(
+        gbl.guppi_from_delta(delta_bound, m_star=1.0, r_bar=0.85),
+        agg_method=gbl.UPPAggrSelector.AVG
+    )
+
+    divr_boundary_i = gbl.DiversionRatioBoundary(
+        gbl.guppi_from_delta(delta_bound, m_star=1.0, r_bar=0.85),
+        agg_method=gbl.UPPAggrSelector.MIN
+    )
+
+    divr_boundary_x = gbl.DiversionRatioBoundary(
+        gbl.guppi_from_delta(delta_bound, m_star=1.0, r_bar=0.85),
+        agg_method=gbl.UPPAggrSelector.MAX
+    )
+
+
+Plots are written to PDF, typically, with ``backend="pgf"`` as the
+default backend in the function, ``gbf.boundary_plot``. Here, we set the
+backend to ``None`` to skip fine-tuning plots for PDF generation.
+
+.. code:: python
+
+    plt, fig, ax, layout_axis = gbf.boundary_plot(backend=None)
+
+    ax.set_title("Concentration and Diversion Ratio Boundaries")
+
+    ax.plot(conc_boundary.coordinates[:, 0], conc_boundary.coordinates[:, 1], color="black", linestyle="-", label="ΔHHI")
+    ax.plot(share_boundary.coordinates[:, 0], share_boundary.coordinates[:, 1], color="black", linestyle=":", label="Combined share")
+    ax.plot(divr_boundary_a.coordinates[:, 0], divr_boundary_a.coordinates[:, 1], "b-", label="Average Diversion Ratio")
+    ax.plot(divr_boundary_i.coordinates[:, 0], divr_boundary_i.coordinates[:, 1], "r-", label="Minimum Diversion Ratio")
+    ax.plot(divr_boundary_x.coordinates[:, 0], divr_boundary_x.coordinates[:, 1], "g-", label="Maximum Diversion Ratio")
+
+    _ = fig.legend(loc=(0.4, 0.7), frameon=False)
+
+
+
+.. image:: ./docs/readme_content/output_5_0.png
+
+
+*Analyzing FTC Merger Investigations Data*
+
+.. code:: python
+
+    from mergeron.core import ftc_merger_investigations_data as fid
+    import tabulate
+
+    inv_data = fid.construct_data(fid.INVDATA_ARCHIVE_PATH)
+
+
+We can now analyze counts of markets reported in the source data, by
+table number. Note that odd-numbered tables report FTC investigations
+data organized by HHI and ΔHHI, while even-numbered tables report by
+firm-count.
+
+.. code:: python
+
+    from mergeron.gen import enforcement_stats as esl
+
+    print("Enforcement Rates in Markets with Entry Barriers, 1996-2003 vs 2004-2011")
+    print()
+    counts_by_delta_1 = esl.enf_cnts_bydelta(
+        inv_data["1996-2003"]["ByHHIandDelta"]["Table 9.2"].data_array
+    )
+    counts_by_delta_2 = esl.enf_cnts_bydelta(
+        inv_data["2004-2011"]["ByHHIandDelta"]["Table 9.2"].data_array
+    )
+    observed_enforcement_rates = list(zip(
+        (
+            {_v: _k for _k, _v in fid.CONC_DELTA_DICT.items()}[i]
+            for i in counts_by_delta_1[:, 0]
+        ),
+        (
+            f"{_a[1] / _a[-1]: <12.2%}" if _a[-1] else "--"
+            for _a in counts_by_delta_1
+        ),
+        (
+            f"{_e[1] / _e[-1]: <12.2%}" if _e[-1] else "--"
+            for _e in counts_by_delta_2
+        ),
+    ))
+
+    observed_enforcement_rates.append([
+        "Total",
+        f"{counts_by_delta_1[:, 1].sum() / counts_by_delta_1[:, -1].sum(): <12.2%}",
+        f"{counts_by_delta_2[:, 1].sum() / counts_by_delta_2[:, -1].sum(): <12.2%}",
+    ])
+
+    print(tabulate.tabulate(
+        observed_enforcement_rates,
+        tablefmt="simple",
+        headers=("ΔHHI", "1996-2003", "2004-2011"),
+        stralign="center",
+        maxcolwidths=36,
+        maxheadercolwidths=36,
+    ))
+
+
+.. parsed-literal::
+
+    Enforcement Rates in Markets with Entry Barriers, 1996-2003 vs 2004-2011
+
+        ΔHHI        1996-2003    2004-2011
+    -------------  -----------  -----------
+       0 - 100         --         100.00%
+      100 - 200      33.33%       50.00%
+      200 - 300      33.33%       50.00%
+      300 - 500      75.00%       77.78%
+      500 - 800      59.09%       54.55%
+     800 - 1,200     93.33%       81.82%
+    1,200 - 2,500    90.91%       84.38%
+       2,500 +       96.00%       100.00%
+        Total        81.65%       82.86%
+
+
+Generating synthetic market data and analyzing enforcement rates
+
+
+

mergeron-2025.739290.9/README.rst

@@ -0,0 +1,136 @@
+mergeron: Merger Policy Analysis with Python
+============================================
+
+Usage
+-----
+
+*Visualizing Guidelines boundaries*
+
+.. code:: python
+
+    %matplotlib inline
+    from mergeron.core import guidelines_boundaries as gbl
+    from mergeron.core import guidelines_boundary_functions as gbf
+    from math import sqrt
+
+    delta_bound = 0.01
+    conc_boundary = gbl.ConcentrationBoundary(delta_bound, "ΔHHI")
+    share_boundary = gbl.ConcentrationBoundary(2 * sqrt(delta_bound / 2), "Combined share")
+
+    divr_boundary_a = gbl.DiversionRatioBoundary(
+        gbl.guppi_from_delta(delta_bound, m_star=1.0, r_bar=0.85),
+        agg_method=gbl.UPPAggrSelector.AVG
+    )
+
+    divr_boundary_i = gbl.DiversionRatioBoundary(
+        gbl.guppi_from_delta(delta_bound, m_star=1.0, r_bar=0.85),
+        agg_method=gbl.UPPAggrSelector.MIN
+    )
+
+    divr_boundary_x = gbl.DiversionRatioBoundary(
+        gbl.guppi_from_delta(delta_bound, m_star=1.0, r_bar=0.85),
+        agg_method=gbl.UPPAggrSelector.MAX
+    )
+
+
+Plots are written to PDF, typically, with ``backend="pgf"`` as the
+default backend in the function, ``gbf.boundary_plot``. Here, we set the
+backend to ``None`` to skip fine-tuning plots for PDF generation.
+
+.. code:: python
+
+    plt, fig, ax, layout_axis = gbf.boundary_plot(backend=None)
+
+    ax.set_title("Concentration and Diversion Ratio Boundaries")
+
+    ax.plot(conc_boundary.coordinates[:, 0], conc_boundary.coordinates[:, 1], color="black", linestyle="-", label="ΔHHI")
+    ax.plot(share_boundary.coordinates[:, 0], share_boundary.coordinates[:, 1], color="black", linestyle=":", label="Combined share")
+    ax.plot(divr_boundary_a.coordinates[:, 0], divr_boundary_a.coordinates[:, 1], "b-", label="Average Diversion Ratio")
+    ax.plot(divr_boundary_i.coordinates[:, 0], divr_boundary_i.coordinates[:, 1], "r-", label="Minimum Diversion Ratio")
+    ax.plot(divr_boundary_x.coordinates[:, 0], divr_boundary_x.coordinates[:, 1], "g-", label="Maximum Diversion Ratio")
+
+    _ = fig.legend(loc=(0.4, 0.7), frameon=False)
+
+
+
+.. image:: ./docs/readme_content/output_5_0.png
+
+
+*Analyzing FTC Merger Investigations Data*
+
+.. code:: python
+
+    from mergeron.core import ftc_merger_investigations_data as fid
+    import tabulate
+
+    inv_data = fid.construct_data(fid.INVDATA_ARCHIVE_PATH)
+
+
+We can now analyze counts of markets reported in the source data, by
+table number. Note that odd-numbered tables report FTC investigations
+data organized by HHI and ΔHHI, while even-numbered tables report by
+firm-count.
+
+.. code:: python
+
+    from mergeron.gen import enforcement_stats as esl
+
+    print("Enforcement Rates in Markets with Entry Barriers, 1996-2003 vs 2004-2011")
+    print()
+    counts_by_delta_1 = esl.enf_cnts_bydelta(
+        inv_data["1996-2003"]["ByHHIandDelta"]["Table 9.2"].data_array
+    )
+    counts_by_delta_2 = esl.enf_cnts_bydelta(
+        inv_data["2004-2011"]["ByHHIandDelta"]["Table 9.2"].data_array
+    )
+    observed_enforcement_rates = list(zip(
+        (
+            {_v: _k for _k, _v in fid.CONC_DELTA_DICT.items()}[i]
+            for i in counts_by_delta_1[:, 0]
+        ),
+        (
+            f"{_a[1] / _a[-1]: <12.2%}" if _a[-1] else "--"
+            for _a in counts_by_delta_1
+        ),
+        (
+            f"{_e[1] / _e[-1]: <12.2%}" if _e[-1] else "--"
+            for _e in counts_by_delta_2
+        ),
+    ))
+
+    observed_enforcement_rates.append([
+        "Total",
+        f"{counts_by_delta_1[:, 1].sum() / counts_by_delta_1[:, -1].sum(): <12.2%}",
+        f"{counts_by_delta_2[:, 1].sum() / counts_by_delta_2[:, -1].sum(): <12.2%}",
+    ])
+
+    print(tabulate.tabulate(
+        observed_enforcement_rates,
+        tablefmt="simple",
+        headers=("ΔHHI", "1996-2003", "2004-2011"),
+        stralign="center",
+        maxcolwidths=36,
+        maxheadercolwidths=36,
+    ))
+
+
+.. parsed-literal::
+
+    Enforcement Rates in Markets with Entry Barriers, 1996-2003 vs 2004-2011
+
+        ΔHHI        1996-2003    2004-2011
+    -------------  -----------  -----------
+       0 - 100         --         100.00%
+      100 - 200      33.33%       50.00%
+      200 - 300      33.33%       50.00%
+      300 - 500      75.00%       77.78%
+      500 - 800      59.09%       54.55%
+     800 - 1,200     93.33%       81.82%
+    1,200 - 2,500    90.91%       84.38%
+       2,500 +       96.00%       100.00%
+        Total        81.65%       82.86%
+
+
+Generating synthetic market data and analyzing enforcement rates
+
+

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

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

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

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

{mergeron-2025.739290.7 → mergeron-2025.739290.9}/src/mergeron/core/empirical_margin_distribution.py

@@ -238,7 +238,7 @@ def margin_data_resampler(
 
     """
 
-    seed_sequence_ = seed_sequence or SeedSequence(pool_size=8)
+    _seed = seed_sequence or SeedSequence(pool_size=8)
 
     _x, _w, _ = margin_data_builder(margin_data_getter())
 
@@ -247,16 +247,14 @@ def margin_data_resampler(
 
     if isinstance(_sample_size, int):
         return np.array(
-            margin_kde.resample(
-                _sample_size, seed=Generator(PCG64DXSM(seed_sequence_))
-            )[0]
+            margin_kde.resample(_sample_size, seed=Generator(PCG64DXSM(_seed)))[0]
         )
     elif isinstance(_sample_size, tuple) and len(_sample_size) == 2:
-        ssz, num_cols = _sample_size
-        ret_array = np.empty(_sample_size, np.float64)
-        for idx, seed_seq in enumerate(seed_sequence_.spawn(num_cols)):
+        _ssz, _ncol = _sample_size
+        ret_array = np.empty(_sample_size, float)
+        for idx, _col_seed in enumerate(_seed.spawn(_ncol)):
             ret_array[:, idx] = margin_kde.resample(
-                ssz, seed=Generator(PCG64DXSM(seed_seq))
+                _ssz, seed=Generator(PCG64DXSM(_col_seed))
             )[0]
         return ret_array
     else:

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

@@ -243,7 +243,7 @@ def _construct_no_evidence_data(_invdata: INVData_in, _data_period: str, /) -> N
                 dtn: INVTableData(
                     invdata_ind_grp,
                     invdata_evid_cond,
-                    np.column_stack((
+                    np.hstack((
                         invdata_sub_evid_cond_conc[stn0].data_array[:, :2],
                         (
                             invdata_sub_evid_cond_conc[stn0].data_array[:, 2:]
@@ -377,10 +377,10 @@ def _construct_new_period_data(
                     np.zeros_like(invdata_array_bld_enfcls),
                 )).max(axis=0)
 
-            invdata_array_bld = np.column_stack((
+            invdata_array_bld = np.hstack((
                 invdata_cuml_array[:, :-3],
                 invdata_array_bld_enfcls,
-                np.einsum("ij->i", invdata_array_bld_enfcls),
+                np.einsum("ij->i", invdata_array_bld_enfcls)[:, None],
             ))
 
             data_typesubdict[table_no] = INVTableData(
@@ -401,7 +401,7 @@ def invdata_build_aggregate_table(
     return INVTableData(
         "Industries in Common",
         "Unrestricted on additional evidence",
-        np.column_stack((
+        np.hstack((
             _data_typesub[hdr_table_no].data_array[:, :-3],
             np.einsum(
                 "ijk->jk",

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

@@ -99,7 +99,7 @@ def hhi_delta_boundary(
 
     # Boundary points
     half_bdry = np.vstack((
-        np.column_stack((_s_1, _delta_bound / (2 * _s_1))).astype(float),
+        np.stack((_s_1, _delta_bound / (2 * _s_1)), axis=1).astype(float),
         np.array([(mpf("0.0"), mpf("1.0"))], float),
     ))
     bdry = np.vstack((half_bdry[::-1], half_bdry[1:, ::-1]), dtype=float)
@@ -132,7 +132,7 @@ def hhi_pre_contrib_boundary(
     # 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)
+    half_bdry = np.stack((s_1, s_2), axis=1).astype(float)
 
     return GuidelinesBoundary(
         np.vstack((half_bdry[::-1], half_bdry[1:, ::-1]), dtype=float),
@@ -536,7 +536,7 @@ def shrratio_boundary_xact_avg(  # noqa: PLR0914
             )
         )
 
-    bdry_inner = np.column_stack((_s_1, s_2))
+    bdry_inner = np.stack((_s_1, s_2), axis=1)
     bdry_end = np.array([(mpf("0.0"), _s_intcpt)], float)
 
     bdry = np.vstack((

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

@@ -506,7 +506,7 @@ def shrratio_boundary_xact_avg_mp(  # noqa: PLR0914
             )
         )
 
-    bdry_inner = np.column_stack((_s_1, s_2))
+    bdry_inner = np.stack((_s_1, s_2), axis=1)
     bdry_end = np.array([(mpf("0.0"), s_intcpt)])
 
     bdry = np.vstack((

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

@@ -27,6 +27,7 @@ from ..core import guidelines_boundaries as gbl  # noqa: TID252
 from ..core.guidelines_boundaries import HMGThresholds  # noqa: TID252
 from . import (
     FM2Constraint,
+    INVResolution,  # noqa: F401
     MarketSampleData,
     PCMDistribution,
     PCMSpec,
@@ -396,7 +397,7 @@ class MarketSample:
             for _k in ("by_firm_count", "by_delta", "by_conczone")
         ])
         upp_test_results = UPPTestsCounts(*[
-            np.column_stack((
+            np.hstack((
                 (_gv := getattr(res_list_stacks, _g.name))[0, :, :_h],
                 np.einsum("ijk->jk", _gv[:, :, _h:], dtype=np.int64),
             ))

{mergeron-2025.739290.7 → mergeron-2025.739290.9}/src/mergeron/gen/data_generation_functions.py

@@ -722,7 +722,7 @@ def _gen_margin_data(
         del beta_min, beta_max
 
     if dist_firm2_pcm == FM2Constraint.SYM:
-        pcm_array = np.column_stack((pcm_array,) * _frmshr_array.shape[1])
+        pcm_array = np.hstack((pcm_array,) * _frmshr_array.shape[1])
     if dist_firm2_pcm == FM2Constraint.MNL:
         # Impose FOCs from profit-maximization with MNL demand
         if dist_type_pcm == PCMDistribution.EMPR:

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

@@ -193,7 +193,7 @@ def enf_cnts_obs_byfirmcount(
         case INVResolution.BOTH:
             stats_kept_indxs = [-1, -3, -2]
 
-    return np.column_stack([cnts_array[:, :ndim_in], cnts_array[:, stats_kept_indxs]])
+    return np.hstack([cnts_array[:, :ndim_in], cnts_array[:, stats_kept_indxs]])
 
 
 def enf_cnts_obs_byhhianddelta(
@@ -226,7 +226,7 @@ def enf_cnts_obs_byhhianddelta(
         case INVResolution.BOTH:
             stats_kept_indxs = [-1, -3, -2]
 
-    return np.column_stack([cnts_array[:, :ndim_in], cnts_array[:, stats_kept_indxs]])
+    return np.hstack([cnts_array[:, :ndim_in], cnts_array[:, stats_kept_indxs]])
 
 
 def table_no_lku(
@@ -335,10 +335,10 @@ def enf_cnts_byconczone(_cnts_array: ArrayBIGINT, /) -> ArrayBIGINT:
         # Logical-and of multiple vectors:
         hhi_zone_test = (
             1
-            * np.column_stack([
+            * np.stack([
                 cnts_byhhipostanddelta[:, _idx] == _val
                 for _idx, _val in enumerate(zone_val)
-            ])
+            ], axis=1)
         ).prod(axis=1) == 1
 
         cnts_byconczone = np.vstack((

mergeron-2025.739290.7/PKG-INFO

@@ -1,115 +0,0 @@
-Metadata-Version: 2.3
-Name: mergeron
-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
-Author: Murthy Kambhampaty
-Author-email: smk@capeconomics.com
-Requires-Python: >=3.12,<4.0
-Classifier: Development Status :: 4 - Beta
-Classifier: Environment :: Console
-Classifier: Intended Audience :: End Users/Desktop
-Classifier: Intended Audience :: Science/Research
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: Implementation :: CPython
-Requires-Dist: aenum (>=3.1.15,<4.0.0)
-Requires-Dist: attrs (>=23.2)
-Requires-Dist: bs4 (>=0.0.1)
-Requires-Dist: certifi (>=2023.11.17)
-Requires-Dist: h5py (>=3.13.0,<4.0.0)
-Requires-Dist: jinja2 (>=3.1)
-Requires-Dist: joblib (>=1.3)
-Requires-Dist: matplotlib (>=3.8)
-Requires-Dist: mpmath (>=1.3)
-Requires-Dist: msgpack (>=1.0)
-Requires-Dist: msgpack-numpy (>=0.4)
-Requires-Dist: ruamel-yaml (>=0.18.10,<0.19.0)
-Requires-Dist: scipy (>=1.12)
-Requires-Dist: sympy (>=1.12)
-Requires-Dist: types-beautifulsoup4 (>=4.11.2)
-Requires-Dist: urllib3 (>=2.2.2,<3.0.0)
-Requires-Dist: xlrd (>=2.0.1,<3.0.0)
-Requires-Dist: xlsxwriter (>=3.1)
-Description-Content-Type: text/x-rst
-
-mergeron: Merger Policy Analysis using Python
-=============================================
-
-Visualize the sets of mergers conforming to concentration and diversion-ratio standards. Estimate intrinsic enforcement rates, and intrinsic clearance rates, under concentration, diversion ratio, GUPPI, CMCR, and IPR bounds using generated data with specified distributions of market shares, price-cost margins, firm counts, and prices, optionally imposing restrictions implied by statutory filing thresholds and/or Bertrand-Nash oligopoly with MNL demand. Download and analyze merger investigations data published by the U.S. Federal Trade Commission in various reports on extended merger investigations (Second Requests) during 1996 to 2011.
-
-Here, enforcement rates derived with merger enforcement as being exogenous to firm conduct are defined as intrinsic enforcement rates, and similarly intrinsic clearance rates. Depending on the merger enforcement regime, or merger control regime, intrinsic enforcement rates may also not be the complement of intrinsic clearance rates, i.e, it is not necessarily true that the intrinsic clearance rate estimate for a given enforcement regime is 1 minus the intrinsic enforcement rate. In contrast, observed enforcement rates reflect the deterrent effects of merger enforcement on firm conduct as well as the effects of merger screening on the level of enforcement; and, by definition, the observed clearance rate is 1 minus the observed enforcement rate.
-
-Introduction
-------------
-
-Module :code:`.core.guidelines_boundaries` includes classes for specifying concentration bounds (:code:`.core.guidelines_boundaries.ConcentrationBoundary`) and diversion-ratio bounds (:code:`.core.guidelines_boundaries.DiversionRatioBoundary`), with automatic generation of boundary, as an array of share-pairs, and area. This module also includes a function for generating plots of concentration and diversion-ratio boundaries, and functions for mapping GUPPI standards to concentration (ΔHHI) standards, and vice-versa.
-
-Module :code:`.gen.data_generation` includes the :code:`.gen.data_generation.MarketSample` which provides for a rich specification of shares and diversion ratios (:code:`.gen.data_generation.MarketSample.share_spec`), margins (:code:`.gen.data_generation.MarketSample.pcm_spec`, prices (:code:`.gen.data_generation.MarketSample.price_spec`), and HSR filing requirements (:code:`.gen.data_generation.MarketSample.hsr_filing_test_type`), and with methods for, (i) generating sample data (:code:`.gen.data_generation.MarketSample.generate_sample`), and (ii) computing the intrinsic enforcement rate and intrinsic clearance rate for the generated sample, given a method (:code:`.UPPAggrSelector`) of aggregating diversion ratio or GUPPI estimates for the firms in a merger (:code:`.gen.data_generation.MarketSample.estimate_enf_counts`). While the latter populate the properties, :code:`.gen.data_generation.MarketSample.data`
-and :code:`.gen.data_generation.MarketSample.enf_counts`, respectively, the underlying methods for generating standalone :code:`MarketDataSample` and :code:`UPPTestCounts` objects are included in the class definition, with helper functions defined in the modules, :code:`.gen.data_generation_functions` and :code:`.gen.upp_tests`. Notably, market shares are generated for a sample of markets with firm-count distributed as specified in :code:`.gen.data_generation.MarketSample.share_spec.firm_count_weights`, with defaults as discussed below (also see, :code:`.gen.ShareSpec.firm_count_weights`.
-
-By default, merging-firm shares are drawn with uniform distribution over the space :math:`s_1 + s_2 \leqslant 1` for an unspecified number of firms. Alternatively, shares may be drawn from the Dirichlet distribution (see property `dist_type` of :code:`.gen.data_generation.MarketSample.share_spec`, of type, :code:`.gen.SHRDistribution`), with specified shape parameters (property `dist_parms` of :code:`.gen.data_generation.MarketSample.share_spec`. When drawing shares from the Dirichlet distribution, the user specifies the `firm_count_weights` property of :code:`.gen.data_generation.MarketSample.share_spec`, as a vector of weights specifying the frequency distribution over sequential firm counts, e.g., :code:`[133, 184, 134, 52, 32, 10, 12, 4, 3]` to specify shares drawn from Dirichlet distributions with 2 to 10 pre-merger firms distributed as in data for FTC merger investigations during 1996--2003 (See, for example, Table 4.1 of `FTC, Horizontal Merger Investigations Data, Fiscal Years 1996--2003 (Revised: August 31, 2004) <https://www.ftc.gov/sites/default/files/documents/reports/horizontal-merger-investigation-data-fiscal-years-1996-2003/040831horizmergersdata96-03.pdf>`_). If the property `firm_count_weights` is not explicitly assigned a value when defining :code:`.gen.data_generation.MarketSample.share_spec`, the default values is used, which results in a sample of markets with 2 to 7 firms with relative frequency in inverse proportion to firm-count, with 2-firm markets being 6 times as likely to be drawn as 7-firm markets.
-
-Recapture ratios can be specified as, "proportional", "inside-out", or "outside-in" (see :code:`.RECForm`). The "inside-out" specification (assigning :code:`.RECForm.INOUT` to the `recapture_form` property of :code:`.gen.data_generation.MarketSample.share_spec`) results in recapture ratios consistent with MNL demand, given merging-firms' in-market shares and a default recapture ratio. The "outside-in" specification (assigning :code:`.RECForm.INOUT` to the `recapture_form` property of :code:`.gen.data_generation.MarketSample.share_spec`) yields diversion ratios from purchase probabilities drawn at random for :math:`N+1` goods, with market shares and recapture ratios for the :math:`N` goods in the putative market (see, :code:`.gen.ShareSpec`) computed from the simulated choice probabilities. The "outside-in" specification requires specification of the distribution of markets over firm counts (the default being uniform distirbution over markets with 2 to 7 firms pre-merger), and Dirichlet-distributed shares, with optional parameters (the default being a "flat" Dirichlet distribution, i.e., one with all parameters being 1). The parameters of the Dirichlet distribution can, for example, be specified to increase (decrease) the probability of drawing mergers to monopoly relative to that probability associated with the Flat Dirichlet specification, by setting the first 2 specified parameters at higher (lower) values relative to the others. Lastly, the "proportional" form of recapture ratio (`recapture_form` = :code:`.RECForm.FIXED`) is often used in the literature, as an approximation to the "inside-out" calibration. See, for example, Coate (2011).
-
-Price-cost-margins may be specified as having uniform distribution, Beta distribution (including a bounded Beta distribution with specified mean and variance), or a built-in empirical distribution (see, :code:`.gen.PCMSpec`). The in-built empirical margin distribution is based on resampling margin data published by Prof. Damodaran of NYU Stern School of Business (see Notes), using an estimated Gaussian KDE. The second merging firm's margin (per the property `firm2_pcm_constraint` of :code:`.gen.data_generation.MarketSample.pcm_spec`) may be specified as symmetric, i.i.d., or subject to equilibrium conditions for (profit-maximization in) Bertrand-Nash oligopoly with MNL demand (:code:`.gen.FM2Constraint`).
-
-Prices may be specified as symmetric or asymmetric, and in the latter case, the direction of correlation between merging firm prices, if any, can also be specified (see, :code:`.gen.PriceSpec`). Prices may also be defined by imposing cost symmetry on firms in the sample, with fixed unit marginal costs normalized to 1 unit, such that prices equal :math:`1 / (1 - \pmb{m})`, where :math:`\pmb{m}` represents the array of margins for firms in the sample.
-
-The market sample may be restricted to mergers meeting the HSR filing requirement under two alternative approaches: in the one, the smaller of the two merging firms meets the lower HSR size threshold ($10 million, as adjusted) and the larger of the two merging firms meets the size test if it's share is no less than 10 times the share of the smaller firm. In the other, the :math:`n`-th firm's size is maintained as $10 million, as adjusted (see, :code:`.gen.SSZConstant`), and a merger meets the HSR filing test if either, (a.) the smaller merging firm is no smaller than the n-th firm and the larger merging firm is at 10-times as large as the n-th firm, or (b.) the smaller merging firm's market share is in excess of 10%; in effect this version of the test maintains that if the smaller merging firm's market share exceeds 10%, the value of the transaction exceeds $200 million, as adjusted, and the size-of-person test is eliminated (see, FTC (2008, p. 12); the above are simplifications of the statutory HSR filing requirements). The second assumption avoids the unfortunate assumption in the first that, within the resulting sample, the larger merging firm be at least 10 times as large as the smaller merging firm, as a consequence of the full definition of the HSR filing requirement.
-
-The full specification of a market sample is given in a :code:`.gen.data_generation.MarketSample` object, including the above parameters. Data are drawn by invoking :code:`.gen.data_generation.MarketSample.generate_sample` which adds a :code:`data` property of class, :code:`.gen.MarketDataSample`. Enforcement or clearance counts are computed by invoking :code:`.gen.data_generation.MarketSample.estimate_enf_counts`, which adds an :code:`enf_counts` property of class :code:`.gen.UPPTestsCounts`. For fast, parallel generation of enforcement or clearance counts over large market data samples that ordinarily would exceed available limits on machine memory, the user can invoke the method :code:`.gen.data_generation.MarketSample.estimate_enf_counts` on a :code:`.gen.data_generation.MarketSample` object without first invoking :code:`.gen.data_generation.MarketSample.generate_sample`. Note, however, that this strategy does not retain the market sample in memory in the interests of conserving memory and maintaining high performance (the user can specify that the market sample and enforcement statistics be stored to permanent storage; when saving to current PCIe NVMe storage, the performance penalty is slight, but can be considerable if saving to SATA storage).
-
-Enforcement statistics based on FTC investigations data and test data are tabulated using methods provided in :code:`.gen.enforcement_stats`.
-
-Programs demonstrating the use of this package are included in the sub-package, :code:`.demo`.
-
-This package includes  a class, :code:`.core.pseudorandom_numbers.MultithreadedRNG` for generating random numbers with selected continuous distribution over specified parameters, and with CPU multithreading on machines with multiple CPU cores, be they virtual, logical, or physical cores. This class is an adaptation from the documentation for the external :code:`numpy.random` subpackage, from the discussion on, "`Multithreaded generation <https://numpy.org/doc/stable/reference/random/multithreading.html>`_"; the version included here permits selection of the distribution with pre-tests to catch and inform on common errors. To access these directly:
-
-.. code-block:: python
-
-    import mergeron.core.pseudorandom_numbers as prng
-
-Documentation for this package is in the form of the API Reference. Documentation for individual functions and classes is accessible within a python shell. For example:
-
-.. code-block:: python
-
-    import mergeron.core.data_generation as dgl
-
-    help(dgl.MarketSample)
-
-.. rubric:: References
-
-.. _coate2011:
-
-Coate, M. B. (2011). Benchmarking the upward pricing pressure model with Federal Trade
-Commission evidence. Journal of Competition Law & Economics, 7(4), 825--846. URL: https://doi.org/10.1093/joclec/nhr014.
-
-.. _ftc_premerger_guide2:
-
-FTC Premerger Notification Office. “To File or Not to File: When You Must File a Premerger Notification Report Form”. 2008 (September, revised). URL: https://www.ftc.gov/sites/default/files/attachments/premerger-introductory-guides/guide2.pdf
-
-
-.. image:: https://img.shields.io/endpoint?url=https://python-poetry.org/badge/v0.json
-   :alt: Poetry
-   :target: https://python-poetry.org/
-
-.. image:: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json
-   :alt: Ruff
-   :target: https://github.com/astral-sh/ruff/
-
-.. image:: https://www.mypy-lang.org/static/mypy_badge.svg
-   :alt: Checked with mypy
-   :target: https://mypy-lang.org/
-
-.. image:: https://img.shields.io/badge/License-MIT-yellow.svg
-   :alt: License: MIT
-   :target: https://opensource.org/licenses/MIT/
-
-

mergeron-2025.739290.7/README.rst

@@ -1,73 +0,0 @@
-mergeron: Merger Policy Analysis using Python
-=============================================
-
-Visualize the sets of mergers conforming to concentration and diversion-ratio standards. Estimate intrinsic enforcement rates, and intrinsic clearance rates, under concentration, diversion ratio, GUPPI, CMCR, and IPR bounds using generated data with specified distributions of market shares, price-cost margins, firm counts, and prices, optionally imposing restrictions implied by statutory filing thresholds and/or Bertrand-Nash oligopoly with MNL demand. Download and analyze merger investigations data published by the U.S. Federal Trade Commission in various reports on extended merger investigations (Second Requests) during 1996 to 2011.
-
-Here, enforcement rates derived with merger enforcement as being exogenous to firm conduct are defined as intrinsic enforcement rates, and similarly intrinsic clearance rates. Depending on the merger enforcement regime, or merger control regime, intrinsic enforcement rates may also not be the complement of intrinsic clearance rates, i.e, it is not necessarily true that the intrinsic clearance rate estimate for a given enforcement regime is 1 minus the intrinsic enforcement rate. In contrast, observed enforcement rates reflect the deterrent effects of merger enforcement on firm conduct as well as the effects of merger screening on the level of enforcement; and, by definition, the observed clearance rate is 1 minus the observed enforcement rate.
-
-Introduction
-------------
-
-Module :code:`.core.guidelines_boundaries` includes classes for specifying concentration bounds (:code:`.core.guidelines_boundaries.ConcentrationBoundary`) and diversion-ratio bounds (:code:`.core.guidelines_boundaries.DiversionRatioBoundary`), with automatic generation of boundary, as an array of share-pairs, and area. This module also includes a function for generating plots of concentration and diversion-ratio boundaries, and functions for mapping GUPPI standards to concentration (ΔHHI) standards, and vice-versa.
-
-Module :code:`.gen.data_generation` includes the :code:`.gen.data_generation.MarketSample` which provides for a rich specification of shares and diversion ratios (:code:`.gen.data_generation.MarketSample.share_spec`), margins (:code:`.gen.data_generation.MarketSample.pcm_spec`, prices (:code:`.gen.data_generation.MarketSample.price_spec`), and HSR filing requirements (:code:`.gen.data_generation.MarketSample.hsr_filing_test_type`), and with methods for, (i) generating sample data (:code:`.gen.data_generation.MarketSample.generate_sample`), and (ii) computing the intrinsic enforcement rate and intrinsic clearance rate for the generated sample, given a method (:code:`.UPPAggrSelector`) of aggregating diversion ratio or GUPPI estimates for the firms in a merger (:code:`.gen.data_generation.MarketSample.estimate_enf_counts`). While the latter populate the properties, :code:`.gen.data_generation.MarketSample.data`
-and :code:`.gen.data_generation.MarketSample.enf_counts`, respectively, the underlying methods for generating standalone :code:`MarketDataSample` and :code:`UPPTestCounts` objects are included in the class definition, with helper functions defined in the modules, :code:`.gen.data_generation_functions` and :code:`.gen.upp_tests`. Notably, market shares are generated for a sample of markets with firm-count distributed as specified in :code:`.gen.data_generation.MarketSample.share_spec.firm_count_weights`, with defaults as discussed below (also see, :code:`.gen.ShareSpec.firm_count_weights`.
-
-By default, merging-firm shares are drawn with uniform distribution over the space :math:`s_1 + s_2 \leqslant 1` for an unspecified number of firms. Alternatively, shares may be drawn from the Dirichlet distribution (see property `dist_type` of :code:`.gen.data_generation.MarketSample.share_spec`, of type, :code:`.gen.SHRDistribution`), with specified shape parameters (property `dist_parms` of :code:`.gen.data_generation.MarketSample.share_spec`. When drawing shares from the Dirichlet distribution, the user specifies the `firm_count_weights` property of :code:`.gen.data_generation.MarketSample.share_spec`, as a vector of weights specifying the frequency distribution over sequential firm counts, e.g., :code:`[133, 184, 134, 52, 32, 10, 12, 4, 3]` to specify shares drawn from Dirichlet distributions with 2 to 10 pre-merger firms distributed as in data for FTC merger investigations during 1996--2003 (See, for example, Table 4.1 of `FTC, Horizontal Merger Investigations Data, Fiscal Years 1996--2003 (Revised: August 31, 2004) <https://www.ftc.gov/sites/default/files/documents/reports/horizontal-merger-investigation-data-fiscal-years-1996-2003/040831horizmergersdata96-03.pdf>`_). If the property `firm_count_weights` is not explicitly assigned a value when defining :code:`.gen.data_generation.MarketSample.share_spec`, the default values is used, which results in a sample of markets with 2 to 7 firms with relative frequency in inverse proportion to firm-count, with 2-firm markets being 6 times as likely to be drawn as 7-firm markets.
-
-Recapture ratios can be specified as, "proportional", "inside-out", or "outside-in" (see :code:`.RECForm`). The "inside-out" specification (assigning :code:`.RECForm.INOUT` to the `recapture_form` property of :code:`.gen.data_generation.MarketSample.share_spec`) results in recapture ratios consistent with MNL demand, given merging-firms' in-market shares and a default recapture ratio. The "outside-in" specification (assigning :code:`.RECForm.INOUT` to the `recapture_form` property of :code:`.gen.data_generation.MarketSample.share_spec`) yields diversion ratios from purchase probabilities drawn at random for :math:`N+1` goods, with market shares and recapture ratios for the :math:`N` goods in the putative market (see, :code:`.gen.ShareSpec`) computed from the simulated choice probabilities. The "outside-in" specification requires specification of the distribution of markets over firm counts (the default being uniform distirbution over markets with 2 to 7 firms pre-merger), and Dirichlet-distributed shares, with optional parameters (the default being a "flat" Dirichlet distribution, i.e., one with all parameters being 1). The parameters of the Dirichlet distribution can, for example, be specified to increase (decrease) the probability of drawing mergers to monopoly relative to that probability associated with the Flat Dirichlet specification, by setting the first 2 specified parameters at higher (lower) values relative to the others. Lastly, the "proportional" form of recapture ratio (`recapture_form` = :code:`.RECForm.FIXED`) is often used in the literature, as an approximation to the "inside-out" calibration. See, for example, Coate (2011).
-
-Price-cost-margins may be specified as having uniform distribution, Beta distribution (including a bounded Beta distribution with specified mean and variance), or a built-in empirical distribution (see, :code:`.gen.PCMSpec`). The in-built empirical margin distribution is based on resampling margin data published by Prof. Damodaran of NYU Stern School of Business (see Notes), using an estimated Gaussian KDE. The second merging firm's margin (per the property `firm2_pcm_constraint` of :code:`.gen.data_generation.MarketSample.pcm_spec`) may be specified as symmetric, i.i.d., or subject to equilibrium conditions for (profit-maximization in) Bertrand-Nash oligopoly with MNL demand (:code:`.gen.FM2Constraint`).
-
-Prices may be specified as symmetric or asymmetric, and in the latter case, the direction of correlation between merging firm prices, if any, can also be specified (see, :code:`.gen.PriceSpec`). Prices may also be defined by imposing cost symmetry on firms in the sample, with fixed unit marginal costs normalized to 1 unit, such that prices equal :math:`1 / (1 - \pmb{m})`, where :math:`\pmb{m}` represents the array of margins for firms in the sample.
-
-The market sample may be restricted to mergers meeting the HSR filing requirement under two alternative approaches: in the one, the smaller of the two merging firms meets the lower HSR size threshold ($10 million, as adjusted) and the larger of the two merging firms meets the size test if it's share is no less than 10 times the share of the smaller firm. In the other, the :math:`n`-th firm's size is maintained as $10 million, as adjusted (see, :code:`.gen.SSZConstant`), and a merger meets the HSR filing test if either, (a.) the smaller merging firm is no smaller than the n-th firm and the larger merging firm is at 10-times as large as the n-th firm, or (b.) the smaller merging firm's market share is in excess of 10%; in effect this version of the test maintains that if the smaller merging firm's market share exceeds 10%, the value of the transaction exceeds $200 million, as adjusted, and the size-of-person test is eliminated (see, FTC (2008, p. 12); the above are simplifications of the statutory HSR filing requirements). The second assumption avoids the unfortunate assumption in the first that, within the resulting sample, the larger merging firm be at least 10 times as large as the smaller merging firm, as a consequence of the full definition of the HSR filing requirement.
-
-The full specification of a market sample is given in a :code:`.gen.data_generation.MarketSample` object, including the above parameters. Data are drawn by invoking :code:`.gen.data_generation.MarketSample.generate_sample` which adds a :code:`data` property of class, :code:`.gen.MarketDataSample`. Enforcement or clearance counts are computed by invoking :code:`.gen.data_generation.MarketSample.estimate_enf_counts`, which adds an :code:`enf_counts` property of class :code:`.gen.UPPTestsCounts`. For fast, parallel generation of enforcement or clearance counts over large market data samples that ordinarily would exceed available limits on machine memory, the user can invoke the method :code:`.gen.data_generation.MarketSample.estimate_enf_counts` on a :code:`.gen.data_generation.MarketSample` object without first invoking :code:`.gen.data_generation.MarketSample.generate_sample`. Note, however, that this strategy does not retain the market sample in memory in the interests of conserving memory and maintaining high performance (the user can specify that the market sample and enforcement statistics be stored to permanent storage; when saving to current PCIe NVMe storage, the performance penalty is slight, but can be considerable if saving to SATA storage).
-
-Enforcement statistics based on FTC investigations data and test data are tabulated using methods provided in :code:`.gen.enforcement_stats`.
-
-Programs demonstrating the use of this package are included in the sub-package, :code:`.demo`.
-
-This package includes  a class, :code:`.core.pseudorandom_numbers.MultithreadedRNG` for generating random numbers with selected continuous distribution over specified parameters, and with CPU multithreading on machines with multiple CPU cores, be they virtual, logical, or physical cores. This class is an adaptation from the documentation for the external :code:`numpy.random` subpackage, from the discussion on, "`Multithreaded generation <https://numpy.org/doc/stable/reference/random/multithreading.html>`_"; the version included here permits selection of the distribution with pre-tests to catch and inform on common errors. To access these directly:
-
-.. code-block:: python
-
-    import mergeron.core.pseudorandom_numbers as prng
-
-Documentation for this package is in the form of the API Reference. Documentation for individual functions and classes is accessible within a python shell. For example:
-
-.. code-block:: python
-
-    import mergeron.core.data_generation as dgl
-
-    help(dgl.MarketSample)
-
-.. rubric:: References
-
-.. _coate2011:
-
-Coate, M. B. (2011). Benchmarking the upward pricing pressure model with Federal Trade
-Commission evidence. Journal of Competition Law & Economics, 7(4), 825--846. URL: https://doi.org/10.1093/joclec/nhr014.
-
-.. _ftc_premerger_guide2:
-
-FTC Premerger Notification Office. “To File or Not to File: When You Must File a Premerger Notification Report Form”. 2008 (September, revised). URL: https://www.ftc.gov/sites/default/files/attachments/premerger-introductory-guides/guide2.pdf
-
-
-.. image:: https://img.shields.io/endpoint?url=https://python-poetry.org/badge/v0.json
-   :alt: Poetry
-   :target: https://python-poetry.org/
-
-.. image:: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json
-   :alt: Ruff
-   :target: https://github.com/astral-sh/ruff/
-
-.. image:: https://www.mypy-lang.org/static/mypy_badge.svg
-   :alt: Checked with mypy
-   :target: https://mypy-lang.org/
-
-.. image:: https://img.shields.io/badge/License-MIT-yellow.svg
-   :alt: License: MIT
-   :target: https://opensource.org/licenses/MIT/
-