Fumagalli_Motta_Tarantino_2020.Models.Extension

  1import Fumagalli_Motta_Tarantino_2020.Models.Types as Types
  2import Fumagalli_Motta_Tarantino_2020.Models.Base as Base
  3
  4
  5class ProCompetitive(Base.OptimalMergerPolicy):
  6    """
  7    Relaxes the assumption (A4), that the innovation of the start-up is always welfare beneficial. Instead, the
  8    innovation is only welfare beneficial if the start-up develops and markets the innovation. In contrast, owned by the
  9    incumbent, the innovation reduces the total welfare. This is implying a pure positive effect of the innovation on
 10    competition.
 11    """
 12
 13    def __init__(self, consumer_surplus_without_innovation: float = 0.3, **kwargs):
 14        super(ProCompetitive, self).__init__(
 15            consumer_surplus_without_innovation=consumer_surplus_without_innovation,
 16            **kwargs
 17        )
 18
 19    def _check_assumption_four(self):
 20        assert (
 21            self._success_probability
 22            * (self.w_with_innovation - self.w_without_innovation)
 23            < self.development_costs
 24            < self._success_probability * (self.w_duopoly - self.w_without_innovation)
 25        ), "Adjusted assumption 4 in this model"
 26
 27    def _check_asset_distribution_threshold_strict(self):
 28        pass
 29
 30    def _calculate_h0(self) -> float:
 31        return 0
 32
 33    def _calculate_h1(self) -> float:
 34        return (1 - self.asset_threshold_cdf) * (
 35            self.success_probability * (self.w_duopoly - self.w_without_innovation)
 36            - self.development_costs
 37        )
 38
 39    def _calculate_h2(self) -> float:
 40        return 0
 41
 42    def _solve_game_strict_merger_policy(self) -> None:
 43        assert self.merger_policy is Types.MergerPolicies.Strict
 44        self._set_takeovers(
 45            early_takeover=Types.Takeover.No, late_takeover=Types.Takeover.No
 46        )
 47
 48    def _solve_game_late_takeover_prohibited(self) -> None:
 49        if (
 50            self.asset_threshold_cdf
 51            < self.asset_distribution_threshold_unprofitable_without_late_takeover
 52        ):
 53            self._set_takeovers(early_takeover=Types.Takeover.Pooling)
 54        else:
 55            self._set_takeovers(
 56                early_takeover=Types.Takeover.No, late_takeover=Types.Takeover.No
 57            )
 58
 59    def _solve_game_late_takeover_allowed(self) -> None:
 60        if (
 61            self.asset_threshold_late_takeover_cdf
 62            < self.asset_distribution_threshold_with_late_takeover
 63        ):
 64            self._set_takeovers(early_takeover=Types.Takeover.Pooling)
 65        else:
 66            if self.is_startup_credit_rationed:
 67                self._set_takeovers(
 68                    early_takeover=Types.Takeover.No,
 69                    late_takeover=Types.Takeover.No,
 70                )
 71            else:
 72                if self.development_success:
 73                    self._set_takeovers(late_takeover=Types.Takeover.Pooling)
 74                else:
 75                    self._set_takeovers(
 76                        early_takeover=Types.Takeover.No,
 77                        late_takeover=Types.Takeover.No,
 78                    )
 79
 80    def is_strict_optimal(self) -> bool:
 81        """
 82        In this model a strict merger policy is always optimal.
 83        """
 84        return True
 85
 86    def is_intermediate_optimal(self) -> bool:
 87        """
 88        In this model an intermediate merger policy is never optimal.
 89        """
 90        return False
 91
 92    def is_laissez_faire_optimal(self) -> bool:
 93        """
 94        In this model a laissez-faire merger policy is never optimal.
 95        """
 96        return False
 97
 98
 99class ResourceWaste(ProCompetitive):
100    """
101    In this model is assumed, that the innovation is never welfare beneficial, therefore a development is always a waste
102    of resources regarding total welfare.
103    """
104
105    def __init__(self, consumer_surplus_duopoly=0.41, **kwargs):
106        super(ResourceWaste, self).__init__(
107            consumer_surplus_duopoly=consumer_surplus_duopoly, **kwargs
108        )
109
110    def _check_assumption_four(self):
111        assert (
112            self._success_probability
113            * (self.w_with_innovation - self.w_without_innovation)
114            < self._success_probability * (self.w_duopoly - self.w_without_innovation)
115            < self.development_costs
116        ), "Adjusted assumption 4 in this model"
117
118    def _calculate_h1(self) -> float:
119        return 0
120
121    def _solve_game_strict_merger_policy(self) -> None:
122        assert self.merger_policy is Types.MergerPolicies.Strict
123        if (
124            self.asset_threshold_cdf
125            < self.asset_distribution_threshold_unprofitable_without_late_takeover
126        ):
127            self._set_takeovers(early_takeover=Types.Takeover.Pooling)
128        else:
129            self._set_takeovers(
130                early_takeover=Types.Takeover.No, late_takeover=Types.Takeover.No
131            )
132
133    def is_strict_optimal(self) -> bool:
134        """
135        In this model is a strict merger policy never optimal
136        """
137        return False
138
139    def is_intermediate_optimal(self) -> bool:
140        """
141        Returns whether the intermediate (WITHOUT late takeovers) merger policy is optimal.
142
143        The intermediate (WITHOUT late takeovers) merger is optimal, if a laissez-faire merger policy is not optimal.
144
145        Returns
146        -------
147        True
148            If the intermediate (WITHOUT late takeovers) merger policy is optimal.
149        """
150        return not self.is_laissez_faire_optimal()
151
152    @staticmethod
153    def _get_intermediate_optimal_candidate() -> Types.MergerPolicies:
154        return Types.MergerPolicies.Intermediate_late_takeover_prohibited
155
156    def is_laissez_faire_optimal(self) -> bool:
157        """
158        Returns whether a laissez-faire policy is optimal.
159
160        A laissez-faire policy (that authorises any takeover) is optimal, if:
161        1. Financial imperfections are not severe ($F(\\bar{A}^T)<\\Phi^T(\\cdot)$).
162
163        Or as well if:
164        1. Financial imperfections are always severe ($F(\\bar{A}^T)\\ge\\Phi^T(\\cdot)$ and
165        $F(\\bar{A})\\ge\\Phi(\\cdot)$).
166        2. Detrimental effect of less intense product market competition is dominated by the benefit of making it more
167        likely that the innovation is commercialised (Condition 6 not satisfied).
168
169        Returns
170        -------
171        True
172            If a laissez-faire merger policy is optimal.
173        """
174        return not self.is_financial_imperfection_severe() or (
175            self.is_financial_imperfection_severe()
176            and self.is_financial_imperfection_severe_without_late_takeover()
177            and not self.is_competition_effect_dominating()
178        )
179
180    def is_financial_imperfection_severe_without_late_takeover(self):
181        return (
182            self.asset_threshold_cdf
183            > self.asset_distribution_threshold_unprofitable_without_late_takeover
184        )