Fumagalli_Motta_Tarantino_2020.Models.Base

   1from typing import Optional, Union
   2
   3import Fumagalli_Motta_Tarantino_2020.Models.Types as Types
   4import Fumagalli_Motta_Tarantino_2020.Models.Distributions as Distributions
   5
   6
   7class CoreModel:
   8    """
   9    There are three players in our game: an Antitrust Authority (AA), which at the beginning of the game decides its
  10    merger policy; a monopolist $\t{I}$ncumbent; and a $\t{S}$tart-up. The start-up owns a “prototype” (or project)
  11    that, if developed, can give rise to an innovation: for instance a substitute/higher quality product to the
  12    incumbent’s existing product, or a more efficient production process. The start-up does not have enough own
  13    resources to develop the project. It has two options: it can either obtain additional funds from competitive
  14    capital markets, or sell out to the incumbent. The incumbent will have to decide whether and when it wants to
  15    acquire the start-up (and if it does so before product development, it has to decide whether to develop the
  16    prototype or shelve it), conditional on the AA’s approval of the acquisition. We assume that the takeover
  17    involves a negligible but positive transaction cost. The AA commits at the beginning of the game to a merger
  18    policy, in the form of a maximum threshold of “harm”, that it is ready to tolerate. Harm from a proposed merger
  19    consists of the difference between the expected welfare levels if the merger goes ahead, and in the counterfactual
  20    where it does not take place (derived of course by correctly anticipating the continuation equilibrium of the
  21    game). A proposed merger will be prohibited only if the tolerated harm level H is lower than the expected harm
  22    from the merger, if any.
  23
  24    Timing of the game:
  25
  26    | Time | Action                                                                                                                                                 |
  27    |------|--------------------------------------------------------------------------------------------------------------------------------------------------------|
  28    | 0    | The AA commits to the standard for merger approval, $\\bar{H}$.                                                                                        |
  29    | 1(a) | $\t{I}$ can make a takeover offer to $\t{S}$, which can accept or reject.                                                                              |
  30    | 1(b) | The AA approves or blocks the takeover proposal.                                                                                                       |
  31    | 1(c) | The firm ($\t{I}$ or $\t{S}$) that owns the prototype decides whether to develop or shelve it.                                                         |
  32    | 1(d) | The owner of the prototype engages in financial contracting (if needed). After that, uncertainty about the success or failure of the project resolves. |
  33    | 2(a) | $\t{I}$ can make a take-it-or-leave-it offer to $\t{S}$ (if it did not already buy it at t = 1, and if the development of the project was successful). |
  34    | 2(b) | The AA approves or blocks the takeover proposal.                                                                                                       |
  35    | 3    | Active firms sell in the product market, payoffs are realised and contracts are honored.                                                               |
  36    """
  37
  38    def __init__(
  39        self,
  40        merger_policy: Types.MergerPolicies = Types.MergerPolicies.Strict,
  41        development_costs: float = 0.1,
  42        startup_assets: float = 0.05,
  43        success_probability: float = 0.7,
  44        development_success: bool = True,
  45        private_benefit: float = 0.05,
  46        consumer_surplus_without_innovation: float = 0.2,
  47        incumbent_profit_without_innovation: float = 0.4,
  48        consumer_surplus_duopoly: float = 0.5,
  49        incumbent_profit_duopoly: float = 0.2,
  50        startup_profit_duopoly: float = 0.2,
  51        consumer_surplus_with_innovation: float = 0.3,
  52        incumbent_profit_with_innovation: float = 0.5,
  53        asset_distribution: Union[
  54            Distributions.NormalDistribution, Distributions.UniformDistribution
  55        ] = Distributions.NormalDistribution,
  56        **kwargs,
  57    ):
  58        """
  59        Initializes a valid base model according to the assumptions given in the paper.
  60
  61        The following assumptions have to be met:
  62
  63        | Condition                    | Remark                                                                                                                                                                                                                                                                                                                                                        | Page (Assumption) |
  64        |------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------|
  65        | $\\bar{H} \\ge 0$            | The tolerated level of harm has to be bigger than 0.                                                                                                                                                                                                                                                                                                          | p.6               |
  66        | $p \\in (0,1]$               | Probability that the prototype is developed successfully depends on the non-contractible effort exerted by the entrepreneur of the firm that owns the project. In case of no effort the project fails for sure, but the entrepreneur obtains a positive private benefit. In case of failure the project yields no profit.                                     | p.8               |
  67        | $B>0$                        | Private benefit of the entrepreneur in case of failure.                                                                                                                                                                                                                                                                                                       | p.8               |
  68        | $A \\in (0,K)$               | The startup does not hold sufficient assets at the beginning to cover the costs.                                                                                                                                                                                                                                                                              | p.8               |
  69        | $\\pi^m_I>\\pi^d_I$          | Profit of the incumbent has to be bigger without the innovation than in the duopoly.                                                                                                                                                                                                                                                                          | p.7               |
  70        | $\\pi^M_I>\\pi^m_I$          | Industry profits are higher with a multi-product monopolist than a single product monopolist (otherwise, the incumbent would always shelve).                                                                                                                                                                                                                                                                 | p.7               |
  71        | $CS^M \\ge CS^m$             | Consumer surplus with the innovation has to weakly bigger than without the innovation (consumers like variety).                                                                                                                                                                                                                                                                        | p.7               |
  72        | $\\pi^M_I>\\pi^d_I+\\pi^d_S$ | Industry profits are higher under monopoly than under duopoly. If this assumption did not hold, the takeover would not take place.                                                                                                                                                                                                                            | p.7 (A1)          |
  73        | $\\pi^d_S>\\pi^M_I-\\pi^m_I$ | An incumbent has less incentive to innovate (in a new/better product or a more efficient production process) than a potential entrant because the innovation would cannibalise the incumbent’s current profits. (Corresponds to Arrow's replacement effect)                                                                                                   | p.7 (A2)          |
  74        | $p\\pi^d_S>K$                | In case of effort it is efficient to develop the prototype, i.e., development has a positive net present value (NPV) for the start-up                                                                                                                                                                                                                         | p.8 (A3)          |
  75        | $p(W^M-W^m)>K$               | The development of the project is not only privately beneficial for the start-up, but also for society as a whole, whether undertaken by the incumbent or the start-up (implies $\\;p(W^d-W^m)>K\\;$).                                                                                                                                                                                       | p.8 (A4)          |
  76        | $B-K<0$$B-(p\\pi^d_S-K)>0$   | The first inequality implies that if S shirks the project has negative value; thus, no financial contract could be signed unless the startup makes effort. The second implies that the start-up may be financially constrained, that is, it may hold insufficient assets to fund the development of the prototype even though the project has a positive NPV. | p.8 (A5)          |
  77
  78        Parameters
  79        ----------
  80        development_costs : float
  81            ($K$) Fixed costs to invest for development.
  82        startup_assets : float
  83            ($A$) Assets of the startup at the beginning.
  84        success_probability : float
  85            ($p$) Probability of success in case of effort (otherwise the projects fails for sure).
  86        development_success : bool
  87            Decides whether an attempted development will be successful (true $\\rightarrow$ attempted development succeeds).
  88        private_benefit : float
  89            ($B$) Private benefit of the entrepreneur in case of failure.
  90        consumer_surplus_without_innovation : float
  91            ($CS^m$) Consumer surplus for the case that the innovation is not introduced by the incumbent into the market.
  92        incumbent_profit_without_innovation : float
  93            ($\\pi^m_I$) Profit of the monopolist with a single product (without innovation).
  94        consumer_surplus_duopoly : float
  95            ($CS^d$) Consumer surplus for the case that the innovation is introduced into the market and a duopoly exists.
  96        incumbent_profit_duopoly : float
  97            ($\\pi^d_I$) Profit of the incumbent in the case of a duopoly.
  98        startup_profit_duopoly : float
  99            ($\\pi^d_S$) Profit of the startup in the case of a duopoly.
 100        consumer_surplus_with_innovation : float
 101             ($CS^M$) Consumer surplus for the case that the innovation is introduced by the incumbent into the market.
 102        incumbent_profit_with_innovation : float
 103            ($\\pi^M_I$) Profit of the monopolist with multiple products (with innovation).
 104        """
 105        self._merger_policy = merger_policy
 106        self._development_costs = development_costs
 107        self._startup_assets = startup_assets
 108        self._success_probability = success_probability
 109        self._development_success = development_success
 110        self._private_benefit = private_benefit
 111
 112        # product market payoffs (p.6ff.)
 113        # with innovation
 114        self._incumbent_profit_with_innovation = incumbent_profit_with_innovation
 115        self._cs_with_innovation = consumer_surplus_with_innovation
 116
 117        # without innovation
 118        self._incumbent_profit_without_innovation = incumbent_profit_without_innovation
 119        self._cs_without_innovation = consumer_surplus_without_innovation
 120
 121        # with duopoly
 122        self._startup_profit_duopoly = startup_profit_duopoly
 123        self._incumbent_profit_duopoly = incumbent_profit_duopoly
 124        self._cs_duopoly = consumer_surplus_duopoly
 125
 126        # set asset distribution
 127        self.asset_distribution = asset_distribution
 128        self._set_asset_distribution_kwargs()
 129
 130        # pre-conditions given for the parameters (p.6-8)
 131        self._check_preconditions()
 132
 133    def _set_asset_distribution_kwargs(self) -> None:
 134        if self.asset_distribution is Distributions.UniformDistribution:
 135            self.asset_distribution_kwargs = {
 136                "loc": 0,
 137                "scale": self.development_costs,
 138            }
 139        else:
 140            self.asset_distribution_kwargs = {}
 141
 142    def _check_preconditions(self):
 143        self._check_merger_policy()
 144        # preconditions given (p.6-8)
 145        assert self.private_benefit > 0, "Private benefit has to be bigger than 0"
 146        assert (
 147            0 < self.success_probability <= 1
 148        ), "Success probability of development has to be between 0 and 1"
 149        assert (
 150            0 < self.startup_assets < self.development_costs
 151        ), "Startup has not enough assets for development"
 152        assert (
 153            self.incumbent_profit_without_innovation > self.incumbent_profit_duopoly
 154        ), "Profit of the incumbent has to be bigger without the innovation than in the duopoly"
 155        assert (
 156            self.incumbent_profit_with_innovation
 157            > self.incumbent_profit_without_innovation
 158        ), "Profit of the incumbent has to be bigger with the innovation than without the innovation"
 159        assert (
 160            self.cs_with_innovation >= self.cs_without_innovation
 161        ), "Consumer surplus with the innovation has to weakly bigger than without the innovation"
 162        assert (
 163            self.w_without_innovation < self.w_with_innovation < self.w_duopoly
 164        ), "Ranking of total welfare not valid (p.7)"
 165        assert (
 166            self.development_success is not None
 167        ), "Development success is not optional"
 168        self._check_assumption_one()
 169        self._check_assumption_two()
 170        self._check_assumption_three()
 171        self._check_assumption_four()
 172        self._check_assumption_five()
 173
 174    def _check_merger_policy(self):
 175        assert self._merger_policy is not None
 176
 177    def _check_assumption_five(self):
 178        assert (
 179            self.private_benefit - self.development_costs
 180            < 0
 181            < self.private_benefit
 182            - (
 183                self.success_probability * self._startup_profit_duopoly
 184                - self.development_costs
 185            )
 186        ), "A5 not satisfied (p.8)"
 187
 188    def _check_assumption_four(self):
 189        assert (
 190            self._success_probability
 191            * (self.w_with_innovation - self.w_without_innovation)
 192            > self._development_costs
 193        ), "A4 not satisfied (p.8)"
 194
 195    def _check_assumption_three(self):
 196        assert (
 197            self.success_probability * self.startup_profit_duopoly
 198            > self._development_costs
 199        ), "A3 not satisfied (p.8)"
 200
 201    def _check_assumption_two(self):
 202        assert (
 203            self.startup_profit_duopoly
 204            > self.incumbent_profit_with_innovation
 205            - self.incumbent_profit_without_innovation
 206        ), "A2 not satisfied (p.7)"
 207
 208    def _check_assumption_one(self):
 209        assert (
 210            self.incumbent_profit_with_innovation
 211            > self.incumbent_profit_duopoly + self.startup_profit_duopoly
 212        ), "A1 not satisfied (p.7)"
 213
 214    def _recalculate_model(self) -> None:
 215        """
 216        Organizes the recalculation of the model after a property changed value.
 217        """
 218        self._check_preconditions()
 219
 220    @property
 221    def development_costs(self) -> float:
 222        """
 223        ($K$) Fixed costs to invest for development.
 224        """
 225        return self._development_costs
 226
 227    @development_costs.setter
 228    def development_costs(self, value: float) -> None:
 229        self._development_costs = value
 230        self._recalculate_model()
 231
 232    @property
 233    def startup_assets(self) -> float:
 234        """
 235        ($A$) Assets of the startup at the beginning.
 236        """
 237        return self._startup_assets
 238
 239    @startup_assets.setter
 240    def startup_assets(self, value: float) -> None:
 241        self._startup_assets = value
 242        self._recalculate_model()
 243
 244    @property
 245    def success_probability(self) -> float:
 246        """
 247        ($p$) Probability of success in case of effort (otherwise the projects fails for sure).
 248        """
 249        return self._success_probability
 250
 251    @success_probability.setter
 252    def success_probability(self, value: float) -> None:
 253        self._success_probability = value
 254        self._recalculate_model()
 255
 256    @property
 257    def development_success(self) -> bool:
 258        """
 259        Decides whether an attempted development will be successful.
 260
 261        If true, every attempted development will be successful.
 262        """
 263        return self._development_success
 264
 265    @development_success.setter
 266    def development_success(self, value: bool) -> None:
 267        self._development_success = value
 268        self._recalculate_model()
 269
 270    @property
 271    def private_benefit(self) -> float:
 272        """
 273        ($B$) Private benefit of the entrepreneur in case of failure.
 274        """
 275        return self._private_benefit
 276
 277    @private_benefit.setter
 278    def private_benefit(self, value: float) -> None:
 279        self._private_benefit = value
 280        self._recalculate_model()
 281
 282    @property
 283    def incumbent_profit_with_innovation(self):
 284        """
 285        ($\\pi^M_I$) Profit of the monopolist with multiple products (with innovation).
 286        """
 287        return self._incumbent_profit_with_innovation
 288
 289    @incumbent_profit_with_innovation.setter
 290    def incumbent_profit_with_innovation(self, value: float) -> None:
 291        self._incumbent_profit_with_innovation = value
 292        self._recalculate_model()
 293
 294    @property
 295    def cs_with_innovation(self) -> float:
 296        """
 297        ($CS^M$) Consumer surplus for the case that the innovation is introduced by the incumbent into the market.
 298        """
 299        return self._cs_with_innovation
 300
 301    @cs_with_innovation.setter
 302    def cs_with_innovation(self, value: float) -> None:
 303        self._cs_with_innovation = value
 304        self._recalculate_model()
 305
 306    @property
 307    def w_with_innovation(self) -> float:
 308        """
 309        ($W^M$) Total welfare for the case that the innovation is introduced by the incumbent into the market.
 310        """
 311        return self._cs_with_innovation + self._incumbent_profit_with_innovation
 312
 313    @property
 314    def incumbent_profit_without_innovation(self) -> float:
 315        """
 316        ($\\pi^m_I$) Profit of the monopolist with a single product (without innovation).
 317        """
 318        return self._incumbent_profit_without_innovation
 319
 320    @incumbent_profit_without_innovation.setter
 321    def incumbent_profit_without_innovation(self, value: float) -> None:
 322        self._incumbent_profit_without_innovation = value
 323        self._recalculate_model()
 324
 325    @property
 326    def cs_without_innovation(self) -> float:
 327        """
 328        ($CS^m$) Consumer surplus for the case that the innovation is not introduced by the incumbent into the market.
 329        """
 330        return self._cs_without_innovation
 331
 332    @cs_without_innovation.setter
 333    def cs_without_innovation(self, value: float) -> None:
 334        self._cs_without_innovation = value
 335        self._recalculate_model()
 336
 337    @property
 338    def w_without_innovation(self) -> float:
 339        """
 340        ($W^m$) Total welfare for the case that the innovation is not introduced by the incumbent into the market.
 341        """
 342        return self._cs_without_innovation + self._incumbent_profit_without_innovation
 343
 344    @property
 345    def startup_profit_duopoly(self) -> float:
 346        """
 347        ($\\pi^d_S$) Profit of the startup in the case of a duopoly.
 348        """
 349        return self._startup_profit_duopoly
 350
 351    @startup_profit_duopoly.setter
 352    def startup_profit_duopoly(self, value: float) -> None:
 353        self._startup_profit_duopoly = value
 354        self._recalculate_model()
 355
 356    @property
 357    def incumbent_profit_duopoly(self) -> float:
 358        """
 359        ($\\pi^d_I$) Profit of the incumbent in the case of a duopoly.
 360        """
 361        return self._incumbent_profit_duopoly
 362
 363    @incumbent_profit_duopoly.setter
 364    def incumbent_profit_duopoly(self, value: float) -> None:
 365        self._incumbent_profit_duopoly = value
 366        self._recalculate_model()
 367
 368    @property
 369    def cs_duopoly(self) -> float:
 370        """
 371        ($CS^d$) Consumer surplus for the case that the innovation is introduced into the market and a duopoly exists.
 372        """
 373        return self._cs_duopoly
 374
 375    @cs_duopoly.setter
 376    def cs_duopoly(self, value: float) -> None:
 377        self._cs_duopoly = value
 378        self._recalculate_model()
 379
 380    @property
 381    def w_duopoly(self) -> float:
 382        """
 383        ($W^d$) Total welfare for the case that the innovation is introduced into the market and a duopoly exists.
 384        """
 385        return (
 386            self._cs_duopoly
 387            + self._startup_profit_duopoly
 388            + self._incumbent_profit_duopoly
 389        )
 390
 391
 392class MergerPolicy(CoreModel):
 393    """
 394    In this class all merger policies and their respective outcomes are calculated.
 395
 396    The available merger policies are documented in Fumagalli_Motta_Tarantino_2020.Types.MergerPolicies.
 397    """
 398
 399    def __init__(self, *args, **kwargs):
 400        """
 401        Takes the same arguments as Fumagalli_Motta_Tarantino_2020.Models.Base.CoreModel.__init__.
 402        """
 403        super(MergerPolicy, self).__init__(*args, **kwargs)
 404        self._probability_credit_constrained_default: float = 0
 405        self._probability_credit_constrained_merger_policy: float = 0
 406
 407        self._early_bid_attempt: Optional[Types.Takeover] = None
 408        self._late_bid_attempt: Optional[Types.Takeover] = None
 409        self._early_takeover: Optional[bool] = None
 410        self._late_takeover: Optional[bool] = None
 411
 412        self._check_asset_distribution_thresholds()
 413        self._solve_game()
 414
 415    def _check_asset_distribution_thresholds(self) -> None:
 416        """
 417        Checks the asset distributions thresholds on validity.
 418
 419        Every threshold has to be between 0 and 1. If this condition is not satisfied, an assertion error is raised.
 420        """
 421        assert (
 422            0 < self.asset_distribution_threshold_profitable_without_late_takeover < 1
 423        ), "Violates A.2 (has to be between 0 and 1)"
 424        if self.merger_policy is Types.MergerPolicies.Strict:
 425            self._check_asset_distribution_threshold_strict()
 426        elif (
 427            self.merger_policy
 428            is Types.MergerPolicies.Intermediate_late_takeover_prohibited
 429            and self.is_incumbent_expected_to_shelve()
 430        ):
 431            assert (
 432                0
 433                <= self.asset_distribution_threshold_unprofitable_without_late_takeover
 434                < 1
 435            ), "Violates Condition A-3 (has to be between 0 and 1)"
 436        elif (
 437            self.merger_policy is Types.MergerPolicies.Laissez_faire
 438            and self.is_incumbent_expected_to_shelve()
 439        ):
 440            assert (
 441                0 < self.asset_distribution_threshold_with_late_takeover < 1
 442            ), "Violates Condition 4 (has to be between 0 and 1)"
 443
 444    def _check_asset_distribution_threshold_strict(self):
 445        assert (
 446            0 < self.asset_distribution_threshold_welfare < 1
 447        ), "Violates Condition 2 (has to be between 0 and 1)"
 448
 449    @property
 450    def merger_policy(
 451        self,
 452    ) -> Types.MergerPolicies:
 453        """
 454        Returns the merger policy used to determine the outcome, given by the thresholds for tolerated harm.
 455
 456        The levels of tolerated harm are defined in A.4 (p.36ff.). See Fumagalli_Motta_Tarantino_2020.Types.MergerPolicies
 457        for the available merger policies.
 458        """
 459        return self._merger_policy
 460
 461    @merger_policy.setter
 462    def merger_policy(self, merger_policy: Types.MergerPolicies) -> None:
 463        self._merger_policy = merger_policy
 464        self._check_merger_policy()
 465        self._recalculate_model()
 466
 467    @property
 468    def tolerated_harm(self) -> float:
 469        """
 470        ($\\bar{H}$) The AA commits at the beginning of the game to a merger policy. The tolerated harm is the maximal loss of welfare the AA is ready to accept.
 471        """
 472        if self.merger_policy is Types.MergerPolicies.Strict:
 473            return self._calculate_h0()
 474        if (
 475            self.merger_policy
 476            is Types.MergerPolicies.Intermediate_late_takeover_prohibited
 477        ):
 478            return self._calculate_h1()
 479        if (
 480            self.merger_policy
 481            is Types.MergerPolicies.Intermediate_late_takeover_allowed
 482        ):
 483            return self._calculate_h2()
 484        return float("inf")
 485
 486    @property
 487    def asset_threshold(self) -> float:
 488        """
 489        Threshold level $\\bar{A} = B - (\\pi^d_S - K)$
 490        """
 491        return self.private_benefit - (
 492            self.success_probability * self.startup_profit_duopoly
 493            - self.development_costs
 494        )
 495
 496    @property
 497    def asset_threshold_cdf(self) -> float:
 498        """
 499        Returns the value of the continuous distribution function for the asset threshold.
 500        """
 501        return self.asset_distribution.cumulative(
 502            self.asset_threshold, **self.asset_distribution_kwargs
 503        )
 504
 505    @property
 506    def asset_threshold_late_takeover(self) -> float:
 507        """
 508        The prospect that the start-up will be acquired at $t = 2$ alleviates financial constraints: there exists a
 509        threshold level $\\bar{A}^T = B - (\\pi_I^M - K)$
 510        """
 511        return self.private_benefit - (
 512            self.success_probability * self.incumbent_profit_with_innovation
 513            - self.development_costs
 514        )
 515
 516    @property
 517    def asset_threshold_late_takeover_cdf(self) -> float:
 518        """
 519        Returns the value of the continuous distribution function for the asset threshold under laissez-faire.
 520        """
 521        return self.asset_distribution.cumulative(
 522            self.asset_threshold_late_takeover, **self.asset_distribution_kwargs
 523        )
 524
 525    @CoreModel.startup_assets.setter
 526    def startup_assets(self, value: float) -> None:
 527        CoreModel.startup_assets.fset(self, value)
 528        self._recalculate_model()
 529
 530    @property
 531    def early_bidding_type(self) -> Types.Takeover:
 532        """
 533        Returns the bidding attempt of the incumbent at $t = 1$.
 534
 535        See Fumagalli_Motta_Tarantino_2020.Types.Takeover for the available options.
 536        """
 537        assert self._early_bid_attempt is not None
 538        return self._early_bid_attempt
 539
 540    @property
 541    def late_bidding_type(self) -> Types.Takeover:
 542        """
 543        Returns the bidding attempt of the incumbent at $t = 2$.
 544
 545        See Fumagalli_Motta_Tarantino_2020.Types.Takeover for the available options.
 546        """
 547        assert self._late_bid_attempt is not None
 548        return self._late_bid_attempt
 549
 550    @property
 551    def is_early_takeover(self) -> bool:
 552        """
 553        Returns whether the start-up is acquired by the incumbent at $t=1$.
 554
 555        Returns
 556        -------
 557        True
 558            If the start-up is acquired by the incumbent at $t=1$.
 559        """
 560        assert self._early_takeover is not None
 561        return self._early_takeover
 562
 563    @property
 564    def is_late_takeover(self) -> bool:
 565        """
 566        Returns whether the start-up is acquired by the incumbent at $t=2$.
 567
 568        Returns
 569        -------
 570        True
 571            If the start-up is acquired by the incumbent at $t=2$.
 572        """
 573        assert self._late_takeover is not None
 574        return self._late_takeover
 575
 576    @property
 577    def is_owner_investing(self) -> bool:
 578        """
 579        A start-up that expects external investors to deny financing will not undertake the investment. Conversely, the incumbent
 580        has the financial ability to invest, but it does not always have the incentive to do so. Indeed, the innovation
 581        increases the incumbent’s profits less than the (unconstrained) start-up’s. (This result follows directly from
 582        the Arrow’s replacement effect) The increase in the incumbent’s profits may not be large enough to cover the investment
 583        cost. When this is the case, the incumbent will shelve the project and the acquisition turns out to be a killer acquisition.
 584
 585        Investment decision under the strict merger policy:
 586        - An unconstrained start-up always invests in the development of the prototype.
 587        - The incumbent invests if (and only if): $p*(\\pi^M_I-\\pi^m_I) \\ge K$
 588
 589        Returns
 590        -------
 591        True
 592            If the owner of the innovation at $t=1$ invests in the project, instead of shelving.
 593        """
 594        assert self.is_startup_credit_rationed is not None
 595        assert self.is_early_takeover is not None
 596        if (not self.is_startup_credit_rationed and not self.is_early_takeover) or (
 597            not self.is_incumbent_expected_to_shelve() and self.is_early_takeover
 598        ):
 599            return True
 600        return False
 601
 602    @property
 603    def is_development_successful(self) -> bool:
 604        """
 605        Returns whether the development was successful or not.
 606
 607        The following two conditions have to be satisfied:
 608        - The owner of the product at $t=1$ has to invest in the development
 609        - The development success variable has to be set to True (attempted development always successful).
 610
 611        Returns
 612        -------
 613        True
 614            If both conditions are met.
 615        """
 616        assert self.is_owner_investing is not None
 617        return self.is_owner_investing and self._development_success
 618
 619    @property
 620    def is_startup_credit_rationed(self) -> bool:
 621        """
 622        If no takeover took place at t = 1(b), a start-up that decided to develop the project searches for funding at $t = 1(d)$.
 623
 624        Strict and Intermediate (late takeover prohibited):
 625        - $A < \\bar{A}$, the start-up is credit-rationed and cannot invest.
 626        - $A \\ge \\bar{A}$, the start-up obtains external funding.
 627
 628        Laissez-Faire and Intermediate (late takeover allowed):
 629        - $A < \\bar{A}^T$, the start-up is credit-rationed and cannot invest.
 630        - $A \\ge \\bar{A}^T$, the start-up obtains external funding.
 631
 632        Returns
 633        -------
 634        True
 635            If the start-up is credit rationed.
 636        """
 637        # financial contracting (chapter 3.2)
 638        if self.merger_policy in [
 639            Types.MergerPolicies.Strict,
 640            Types.MergerPolicies.Intermediate_late_takeover_prohibited,
 641        ]:
 642            if self.startup_assets < self.asset_threshold:
 643                return True
 644            return False
 645        if self.startup_assets < self.asset_threshold_late_takeover:
 646            return True
 647        return False
 648
 649    @property
 650    def asset_distribution_threshold_welfare(self) -> float:
 651        """
 652        Threshold defined in Lemma 3 :$\\;\\Gamma(\\cdot)=\\frac{p(W^d-W^M)}{p(W^d-W^m)-K}$
 653        """
 654        return (
 655            self.success_probability * (self.w_duopoly - self.w_with_innovation)
 656        ) / (
 657            self.success_probability * (self.w_duopoly - self.w_without_innovation)
 658            - self.development_costs
 659        )
 660
 661    @property
 662    def asset_distribution_threshold_profitable_without_late_takeover(self) -> float:
 663        """
 664        Threshold defined in Condition 3 :$\\;\\Phi(\\cdot)=\\frac{p(\\pi^M_I-\\pi^d_I-\\pi^d_S)}{p(\\pi^M_I-\\pi^d_I)-K}$
 665        """
 666        return (
 667            self.success_probability
 668            * (
 669                self.incumbent_profit_with_innovation
 670                - self.incumbent_profit_duopoly
 671                - self.startup_profit_duopoly
 672            )
 673        ) / (
 674            self.success_probability
 675            * (self.incumbent_profit_with_innovation - self.incumbent_profit_duopoly)
 676            - self.development_costs
 677        )
 678
 679    @property
 680    def asset_distribution_threshold_with_late_takeover(self) -> float:
 681        """
 682        Threshold defined in Condition 4 :$\\;\\Phi^T(\\cdot)=\\frac{p(\\pi^m_I-\\pi^M_I)+K}{p(\\pi^m_I+\\pi^d_S-\\pi^M_I)}$
 683        """
 684        return (
 685            self.success_probability
 686            * (
 687                self.incumbent_profit_without_innovation
 688                - self.incumbent_profit_with_innovation
 689            )
 690            + self.development_costs
 691        ) / (
 692            self.success_probability
 693            * (
 694                self.incumbent_profit_without_innovation
 695                + self.startup_profit_duopoly
 696                - self.incumbent_profit_with_innovation
 697            )
 698        )
 699
 700    @property
 701    def asset_distribution_threshold_unprofitable_without_late_takeover(self) -> float:
 702        """
 703        Threshold defined in A-3 :$\\;\\Phi^{\\prime}(\\cdot)=\\frac{p(\\pi^m_I-\\pi^d_I-\\pi^d_S)+K}{p(\\pi^m_I+\\pi^d_I)}$
 704        """
 705        return (
 706            self.success_probability
 707            * (
 708                self.incumbent_profit_without_innovation
 709                - self.incumbent_profit_duopoly
 710                - self.startup_profit_duopoly
 711            )
 712            + self.development_costs
 713        ) / (
 714            self.success_probability
 715            * (self.incumbent_profit_without_innovation - self.incumbent_profit_duopoly)
 716        )
 717
 718    def is_incumbent_expected_to_shelve(self) -> bool:
 719        """
 720        Returns whether the incumbent is expected to shelve, whenever it acquires the entrant (Condition 1).
 721
 722        - True (expected to shelve): $p*(\\pi^M_I-\\pi^m_I) < K$
 723
 724        - False (not expected to shelve): $p*(\\pi^M_I-\\pi^m_I) \\ge K$
 725
 726        """
 727        return self.incumbent_expected_additional_profit_from_innovation() < 0
 728
 729    def incumbent_expected_additional_profit_from_innovation(self) -> float:
 730        """
 731        Returns the additional expected profit for the incumbent, if it does not shelve the product after an acquisition.
 732
 733        $ Expected \\; additional \\; profit = p*(\\pi^M_I-\\pi^m_I)-K$
 734        """
 735        return (
 736            self.success_probability
 737            * (
 738                self.incumbent_profit_with_innovation
 739                - self.incumbent_profit_without_innovation
 740            )
 741            - self.development_costs
 742        )
 743
 744    def _calculate_h0(self) -> float:
 745        """
 746        Calculates the minimal threshold of tolerated harm to achieve for an intermediate merger policy (late takeover prohibited).
 747        """
 748        return max(
 749            (1 - self.asset_threshold_cdf)
 750            * (self.success_probability * (self.w_duopoly - self.w_with_innovation))
 751            - self.asset_threshold_cdf
 752            * (
 753                self.success_probability
 754                * (self.w_with_innovation - self.w_without_innovation)
 755                - self.development_costs
 756            ),
 757            0,
 758        )
 759
 760    def _calculate_h1(self) -> float:
 761        """
 762        Calculates the minimal threshold of tolerated harm to achieve for an intermediate merger policy (late takeover allowed).
 763        """
 764        return (1 - self.asset_threshold_cdf) * (
 765            self.success_probability * (self.w_duopoly - self.w_without_innovation)
 766            - self.development_costs
 767        )
 768
 769    def _calculate_h2(self) -> float:
 770        """
 771        Calculates the minimal threshold of tolerated harm to achieve for a laissez-faire merger policy.
 772        """
 773        return max(
 774            self.w_duopoly - self.w_with_innovation,
 775            (1 - self.asset_threshold_late_takeover_cdf)
 776            * (
 777                self.success_probability
 778                * (self.w_with_innovation - self.w_without_innovation)
 779                - self.development_costs
 780            ),
 781        )
 782
 783    def _solve_game(self) -> None:
 784        """
 785        Solves the game according to the set Fumagalli_Motta_Tarantino_2020.Types.MergerPolicies.
 786        """
 787        if self.merger_policy is Types.MergerPolicies.Strict:
 788            self._solve_game_strict_merger_policy()
 789        elif (
 790            self.merger_policy
 791            is Types.MergerPolicies.Intermediate_late_takeover_prohibited
 792        ):
 793            self._solve_game_late_takeover_prohibited()
 794        elif (
 795            self.merger_policy
 796            is Types.MergerPolicies.Intermediate_late_takeover_allowed
 797        ):
 798            self._solve_game_late_takeover_allowed()
 799        else:
 800            self._solve_game_laissez_faire()
 801
 802    def _recalculate_model(self) -> None:
 803        """
 804        Organizes the recalculation of the model after a property changed value.
 805        """
 806        self._reset_takeovers()
 807        super(MergerPolicy, self)._recalculate_model()
 808        self._solve_game()
 809
 810    def _reset_takeovers(self):
 811        self._early_bid_attempt = None
 812        self._late_bid_attempt = None
 813        self._early_takeover = None
 814        self._late_takeover = None
 815
 816    def _solve_game_laissez_faire(self) -> None:
 817        """
 818        Solves the game under a laissez-faire merger policy, based on section 4 in the paper.
 819        """
 820        assert self.merger_policy is Types.MergerPolicies.Laissez_faire
 821        if self.is_incumbent_expected_to_shelve():
 822            if (
 823                self.asset_threshold_late_takeover_cdf
 824                >= self.asset_distribution_threshold_with_late_takeover
 825            ):
 826                if not self.is_startup_credit_rationed and self.development_success:
 827                    self._set_takeovers(late_takeover=Types.Takeover.Pooling)
 828                else:
 829                    self._set_takeovers(
 830                        early_takeover=Types.Takeover.No,
 831                        late_takeover=Types.Takeover.No,
 832                    )
 833            else:
 834                self._set_takeovers(early_takeover=Types.Takeover.Pooling)
 835        else:
 836            if self.is_startup_credit_rationed:
 837                self._set_takeovers(early_takeover=Types.Takeover.Separating)
 838            else:
 839                if self.development_success:
 840                    self._set_takeovers(
 841                        early_takeover=Types.Takeover.Separating,
 842                        early_takeover_accepted=False,
 843                        late_takeover=Types.Takeover.Pooling,
 844                    )
 845                else:
 846                    self._set_takeovers(
 847                        early_takeover=Types.Takeover.Separating,
 848                        early_takeover_accepted=False,
 849                        late_takeover=Types.Takeover.No,
 850                    )
 851
 852    def _solve_game_late_takeover_allowed(self) -> None:
 853        """
 854        Solves the game under an intermediate merger policy (late takeover allowed), based on section 5.2 in the paper.
 855        """
 856        assert (
 857            self.merger_policy
 858            is Types.MergerPolicies.Intermediate_late_takeover_allowed
 859        )
 860        if self.is_incumbent_expected_to_shelve():
 861            if not self.is_startup_credit_rationed and self.development_success:
 862                self._set_takeovers(late_takeover=Types.Takeover.Pooling)
 863            else:
 864                self._set_takeovers(
 865                    early_takeover=Types.Takeover.No, late_takeover=Types.Takeover.No
 866                )
 867        else:
 868            if self.is_startup_credit_rationed:
 869                self._set_takeovers(early_takeover=Types.Takeover.Separating)
 870            else:
 871                if self.development_success:
 872                    self._set_takeovers(
 873                        early_takeover=Types.Takeover.Separating,
 874                        early_takeover_accepted=False,
 875                        late_takeover=Types.Takeover.Pooling,
 876                    )
 877                else:
 878                    self._set_takeovers(
 879                        early_takeover=Types.Takeover.Separating,
 880                        early_takeover_accepted=False,
 881                    )
 882
 883    def _solve_game_late_takeover_prohibited(self) -> None:
 884        """
 885        Solves the game under an intermediate merger policy (late takeover prohibited),
 886        based on section 5.1 in the paper.
 887        """
 888        assert (
 889            self.merger_policy
 890            is Types.MergerPolicies.Intermediate_late_takeover_prohibited
 891        )
 892        if self.is_incumbent_expected_to_shelve():
 893            if (
 894                self.asset_threshold_cdf
 895                >= self.asset_distribution_threshold_unprofitable_without_late_takeover
 896            ):
 897                self._set_takeovers(
 898                    early_takeover=Types.Takeover.No, late_takeover=Types.Takeover.No
 899                )
 900            else:
 901                self._set_takeovers(early_takeover=Types.Takeover.Pooling)
 902        else:
 903            if (
 904                self.asset_threshold_cdf
 905                >= self.asset_distribution_threshold_profitable_without_late_takeover
 906            ):
 907                if self.is_startup_credit_rationed:
 908                    self._set_takeovers(early_takeover=Types.Takeover.Separating)
 909                else:
 910                    self._set_takeovers(
 911                        early_takeover=Types.Takeover.Separating,
 912                        early_takeover_accepted=False,
 913                    )
 914            else:
 915                self._set_takeovers(Types.Takeover.Pooling)
 916
 917    def _solve_game_strict_merger_policy(self) -> None:
 918        """
 919        Solves the game under a strict merger policy, based on section 3 in the paper.
 920        """
 921        assert self.merger_policy is Types.MergerPolicies.Strict
 922        if self.is_incumbent_expected_to_shelve():
 923            self._set_takeovers(
 924                early_takeover=Types.Takeover.No, late_takeover=Types.Takeover.No
 925            )
 926        else:
 927            if (
 928                self.asset_distribution_threshold_welfare
 929                < self.asset_threshold_cdf
 930                < max(
 931                    self.asset_distribution_threshold_profitable_without_late_takeover,
 932                    self.asset_distribution_threshold_welfare,
 933                )
 934            ):
 935                self._set_takeovers(early_takeover=Types.Takeover.Pooling)
 936            else:
 937                if self.is_startup_credit_rationed:
 938                    self._set_takeovers(early_takeover=Types.Takeover.Separating)
 939                else:
 940                    self._set_takeovers(
 941                        early_takeover=Types.Takeover.Separating,
 942                        early_takeover_accepted=False,
 943                    )
 944
 945    def _set_takeovers(
 946        self,
 947        early_takeover: Types.Takeover = Types.Takeover.No,
 948        late_takeover: Types.Takeover = Types.Takeover.No,
 949        early_takeover_accepted=True,
 950        late_takeover_accepted=True,
 951    ) -> None:
 952        """
 953        Sets the takeover variables of the class.
 954
 955        Parameters
 956        ----------
 957        early_takeover: Fumagalli_Motta_Tarantino_2020.Types.Takeover
 958            Type of the early bid attempt/takeover (if existing).
 959        late_takeover: Fumagalli_Motta_Tarantino_2020.Types.Takeover
 960            Type of the early bid attempt/takeover (if existing).
 961        early_takeover_accepted: bool
 962            If true, the early takeover comes through, otherwise the takeover is blocked by AA or the start-up.
 963        late_takeover_accepted
 964            If true, the late takeover comes through, otherwise the takeover is blocked by AA or the start-up.
 965        """
 966        assert self._early_bid_attempt is None and self._early_takeover is None
 967        assert self._late_bid_attempt is None and self._late_takeover is None
 968        assert not (
 969            early_takeover in [Types.Takeover.Separating, Types.Takeover.Pooling]
 970            and early_takeover_accepted
 971            and late_takeover in [Types.Takeover.Separating, Types.Takeover.Pooling]
 972            and late_takeover_accepted
 973        ), "Only one takeover can occur."
 974        self._early_takeover = (
 975            False
 976            if early_takeover is Types.Takeover.No or not early_takeover_accepted
 977            else True
 978        )
 979        self._early_bid_attempt = early_takeover
 980        self._late_takeover = (
 981            False
 982            if late_takeover is Types.Takeover.No or not late_takeover_accepted
 983            else True
 984        )
 985        self._late_bid_attempt = late_takeover
 986
 987    def summary(self) -> Types.Summary:
 988        """
 989        Returns the calculated outcome of the model with the defined parameters.
 990
 991        The resulting dictionary contains the following information (and keys):
 992        - 'set_policy' : Fumagalli_Motta_Tarantino_2020.Types.MergerPolicies -> Defines the chosen merger policy based on the tolerated level of harm.
 993        - 'credit_rationed' : True, if the start-up is credit rationed.
 994        - 'early_bidding_type' : Fumagalli_Motta_Tarantino_2020.Types.Takeover -> Defines the bidding type of the incumbent at t=1.
 995        - 'late_bidding_type' : 'Fumagalli_Motta_Tarantino_2020.Types.Takeover -> Defines the bidding type of the incumbent at t=2.
 996        - 'development_attempt' : True, if the owner (start-up or incumbent after a takeover) tries to develop the product.
 997        - 'development_outcome' : True, if the product is developed successfully.
 998        - 'early_takeover' : True, if a takeover takes place at $t=1$.
 999        - 'late_takeover' : True, if a takeover takes place at $t=2$.
1000
1001        Returns
1002        -------
1003        Fumagalli_Motta_Tarantino_2020.Types.Summary
1004            Containing the result of the model with the defined parameters.
1005        """
1006        return Types.Summary(
1007            set_policy=self.merger_policy,
1008            credit_rationed=self.is_startup_credit_rationed,
1009            early_bidding_type=self.early_bidding_type,
1010            late_bidding_type=self.late_bidding_type,
1011            development_attempt=self.is_owner_investing,
1012            development_outcome=self.is_development_successful,
1013            early_takeover=self.is_early_takeover,
1014            late_takeover=self.is_late_takeover,
1015        )
1016
1017    def is_killer_acquisition(self) -> bool:
1018        """
1019        Returns whether a killer acquisition occurred in the model.
1020
1021        For a killer acquisition to take place the following condition have to satisfied:
1022        - An early takeover takes place
1023        - The incumbent does not develop the product
1024
1025        Returns
1026        -------
1027        True
1028            if a killer acquisition occurred in the model.
1029        """
1030        return self.is_early_takeover and not self.is_owner_investing
1031
1032    def __str__(self) -> str:
1033        return (
1034            f"Merger Policy: {self.merger_policy}\n"
1035            f"Is start-up credit rationed?: {self.is_startup_credit_rationed}\n"
1036            f"Type of early takeover attempt: {self.early_bidding_type}\n"
1037            f"Is the early takeover approved?: {self.is_early_takeover}\n"
1038            f"Does the owner attempt the development?: {self.is_owner_investing}\n"
1039            f"Is the development successful?: {self.is_development_successful}\n"
1040            f"Type of late takeover attempt: {self.late_bidding_type}\n"
1041            f"Is the late takeover approved?: {self.is_late_takeover}"
1042        )
1043
1044
1045class OptimalMergerPolicy(MergerPolicy):
1046    """
1047    Add functionality to determine the optimal merger policy for a given set of parameters.
1048
1049    Annotation: As discussed in section 5.1, a policy that is more lenient with respect to early acquisitions is always
1050    dominated by a strict merger policy. Therefore, only the three remaining policies are discussed.
1051    """
1052
1053    def __init__(self, *args, **kwargs):
1054        super(OptimalMergerPolicy, self).__init__(*args, **kwargs)
1055
1056    def get_optimal_merger_policy(
1057        self,
1058    ) -> Types.MergerPolicies:
1059        """
1060        A strict merger policy is always optimal when the incumbent is expected to invest. When the incumbent is expected
1061        to shelve, a more lenient policy (that either authorises any type of takeover, or that blocks early takeovers when
1062        the incumbent makes a pooling bid and plans to shelve, and authorises late takeovers) may be optimal, but under the
1063        cumulative conditions indicated in proposition 4.
1064
1065        See: OptimalMergerPolicy.is_laissez_faire_optimal, OptimalMergerPolicy.is_intermediate_optimal and OptimalMergerPolicy.is_strict_optimal
1066
1067        """
1068        if self.is_laissez_faire_optimal():
1069            return Types.MergerPolicies.Laissez_faire
1070        if self.is_intermediate_optimal():
1071            return self._get_intermediate_optimal_candidate()
1072        return Types.MergerPolicies.Strict
1073
1074    @staticmethod
1075    def _get_intermediate_optimal_candidate() -> Types.MergerPolicies:
1076        return Types.MergerPolicies.Intermediate_late_takeover_allowed
1077
1078    def is_laissez_faire_optimal(self) -> bool:
1079        """
1080        Returns whether a laissez-faire policy is optimal.
1081
1082        A laissez-faire policy (that authorises any takeover) is optimal, if:
1083        1. Incumbent is expected to shelve ($p(\\pi^M_I-\\pi^m_I) < K$).
1084        2. Financial imperfections are severe ($F(\\bar{A}^T)\\ge\\Phi^T(\\cdot)$).
1085        3. Approving early takeovers followed by shelving is optimal ($F(\\bar{A}^T)\\ge\\Lambda(\\cdot)$).
1086        4. Detrimental effect of less intense product market competition is dominated by the benefit of making it more
1087        likely that the innovation is commercialised (Condition 6 not satisfied).
1088
1089        Returns
1090        -------
1091        True
1092            If a laissez-faire merger policy is optimal.
1093        """
1094        return (
1095            self.is_incumbent_expected_to_shelve()
1096            and self.is_financial_imperfection_severe()
1097            and not self.is_intermediate_policy_feasible()
1098            and not self.is_competition_effect_dominating()
1099        )
1100
1101    def is_intermediate_optimal(self) -> bool:
1102        """
1103        Returns whether an intermediate merger policy (late takeover allowed) is optimal.
1104
1105        An intermediate merger policy (late takeovers allowed) is optimal, if:
1106        1. Incumbent is expected to shelve ($p(\\pi^M_I-\\pi^m_I) < K$).
1107        2. Approving early takeovers followed by shelving is not optimal ($F(\\bar{A}^T) < \\Lambda(\\cdot)$).
1108        3. Detrimental effect of less intense product market competition is dominated by the benefit of making it more
1109        likely that the innovation is commercialised (Condition 6 not satisfied).
1110
1111        Returns
1112        -------
1113        True
1114            If an intermediate merger policy (late takeover allowed) is optimal.
1115        """
1116        return (
1117            self.is_incumbent_expected_to_shelve()
1118            and self.is_intermediate_policy_feasible()
1119            and not self.is_competition_effect_dominating()
1120        )
1121
1122    def is_strict_optimal(self) -> bool:
1123        """
1124        Returns whether the strict merger policy is optimal.
1125
1126        The strict merger is optimal, if the other policies are not optimal.
1127
1128        Returns
1129        -------
1130        True
1131            If the strict merger policy is optimal.
1132        """
1133        return not (self.is_intermediate_optimal() or self.is_laissez_faire_optimal())
1134
1135    def is_competition_effect_dominating(self) -> bool:
1136        """
1137        Condition 6: $\\frac{p(W^d-W^m)-K}{p(W^M-W^m)-K} \\ge \\frac{1-F(\\bar{A}^T)}{1-F(\\bar{A})}$
1138        """
1139        return (
1140            self.success_probability * (self.w_duopoly - self.w_without_innovation)
1141            - self.development_costs
1142        ) / (
1143            self.success_probability
1144            * (self.w_with_innovation - self.w_without_innovation)
1145            - self.development_costs
1146        ) >= (
1147            1 - self.asset_threshold_late_takeover_cdf
1148        ) / (
1149            1 - self.asset_threshold_cdf
1150        )
1151
1152    def is_financial_imperfection_severe(self) -> bool:
1153        """
1154        Returns whether financial imperfections are severe.
1155
1156        Returns
1157        -------
1158        True
1159            If the financial imperfections are severe.
1160        """
1161        return (
1162            self.asset_threshold_late_takeover_cdf
1163            >= self.asset_distribution_threshold_with_late_takeover
1164        )
1165
1166    def is_intermediate_policy_feasible(self) -> bool:
1167        """
1168        Returns whether an intermediate (with late takeovers) merger policy is feasible.
1169
1170        An intermediate policy, which authorizes late takeovers, is feasible if condition 5 is not satisfied.
1171
1172        Returns
1173        -------
1174        True
1175            If an intermediate policy is feasible.
1176        """
1177        return (
1178            self.asset_threshold_late_takeover_cdf
1179            < self.asset_distribution_threshold_shelving_approved
1180        )
1181
1182    @property
1183    def asset_distribution_threshold_shelving_approved(self) -> float:
1184        """
1185        Threshold defined in Condition 5 :$\\;\\Lambda(\\cdot)=\\frac{p(W^M-W^m)-K-(W^d-W^M)}{p(W^M-W^m)-K}$
1186        """
1187        return (
1188            self.success_probability
1189            * (self.w_with_innovation - self.w_without_innovation)
1190            - self.development_costs
1191            - (self.w_duopoly - self.w_with_innovation)
1192        ) / (
1193            self.success_probability
1194            * (self.w_with_innovation - self.w_without_innovation)
1195            - self.development_costs
1196        )
1197
1198    def summary(self) -> Types.OptimalMergerPolicySummary:
1199        """
1200        Returns the calculated outcome of the model with the defined parameters.
1201
1202        Additional information compared to Fumagalli_Motta_Tarantino_2020.Models.MergerPolicy.summary:
1203        - 'optimal_policy' : Fumagalli_Motta_Tarantino_2020.Types.MergerPolicies -> Defines the welfare maximizing merger policy.
1204
1205        Returns
1206        -------
1207        Fumagalli_Motta_Tarantino_2020.Types.OptimalMergerPolicySummary
1208            Containing the result of the model with the defined parameters.
1209        """
1210        return Types.OptimalMergerPolicySummary(
1211            set_policy=self.merger_policy,
1212            credit_rationed=self.is_startup_credit_rationed,
1213            early_bidding_type=self.early_bidding_type,
1214            late_bidding_type=self.late_bidding_type,
1215            development_attempt=self.is_owner_investing,
1216            development_outcome=self.is_development_successful,
1217            early_takeover=self.is_early_takeover,
1218            late_takeover=self.is_late_takeover,
1219            optimal_policy=self.get_optimal_merger_policy(),
1220        )
1221
1222    def __str__(self) -> str:
1223        return (
1224            super(OptimalMergerPolicy, self).__str__()
1225            + f"\nOptimal merger policy: {self.get_optimal_merger_policy()}"
1226        )