my-markdown-library 0.1.0

data/F24Textbook_MD/07-game-theory/bertrand.md

@@ -0,0 +1,257 @@
+---
+title: bertrand
+type: textbook
+source_path: content/07-game-theory/bertrand.ipynb
+chapter: 7
+---
+
+```python
+from datascience import *
+import sympy
+solve = lambda x,y: sympy.solve(x-y)[0] if len(sympy.solve(x-y))==1 else "Not Single Solution"
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+import datetime as dt
+import warnings
+warnings.simplefilter("ignore")
+%matplotlib inline
+```
+
+# Bertrand Competition
+
+Another model we consider is **Bertrand competition**, named for Joseph Louis Francois Bertrand, that is similar to Cournot competition but that firms compete using _prices_ rather than quantity. Under the assumptions of this model, consumers want to buy everything at the lowest price, and if the price is the same then demand is evenly split between those producers. One fundamental assumption is that all firms have the same unit cost of production, which means that as long as the price the firm sets is above the unit cost, it is willing to supply any amount that is demanded. 
+
+An example of a Bertrand oligopoly comes form the soft drink industry: Coke and Pepsi (which form a **duopoly**, a market with only two participants). Both firms compete by changing their prices based on a function that takes into account the price charged by their competitor. This model predicts that even this small competition will result in prices being reduced to the marginal cost level, the same outcome as perfect competition.
+
+## Bertrand Equilibrium
+
+To find the Bertrand equilibrium, let $c$ be the (constant) marginal cost, $p_1$ be firm 1's price level, $p_2$ be firm 2's price level, and $p_m$ be the monopoly price level. Firm 1's price depends on what it believes firm 2 will set its prices to be. Because consumers always buy at the lowest price and the firm will fulfill any level of demand, pricing just below firm 2 will obtain full market demand for firm 1. Why might this not be a good idea? If firm 2 is pricing below the level of marginal cost, then firm 1 will incur losses because they would need to sell at a price lower than the cost of production. 
+
+Let $p'_1(p_2)$ be firm 1's optimal price based on price $p_2$ set by firm 2. The graph below shows $p'_1(p_2)$. Note that when $p_2 < c$, $p'_1$ is equal to $c$, that $p'_1$ rises linearly along but _just below_ the line $p_1 = p_2$ with $p_2$ until $p_2$ reaches $p_m$ (the monopoly price level), and that it then levels off at $p_m$. In this way, firm 1's price stays below firm 2's price when it is not operating at a loss and does not exceed $p_m$ (because $p_m$ is the profit-maximizing amount for a monopoly and producing more actually results in less profit). This piecewise function has the formula
+
+$$
+p'_1(p_2) = \begin{cases}
+c & \text{if } p_2 < c + h \\
+p_2 - h & \text{if } c + h \le p_2 < p_m + h \\
+p_m & \text{otherwise}
+\end{cases}
+$$
+
+where $h$ is a small positive value and indicates the vertical distance between $p'_1$ and the line $p_1 = p_2$. We can think of $h$ as the amount by which firm 1 will undercut firm 2: as long as firm 1 will be operating at a profit and not exceeding $p_m$, they will sell at $h$ dollars below $p_2$.
+
+[Following image has line graphs for price response functions between two firms]
+
+```python
+p_m = 18
+c = 6
+dist = 0.4 # the distance from p_1 = p_2 to p'_1(p_2)
+
+xs1 = np.linspace(0, c, 100)
+ys1 = c * np.ones_like(xs1)
+
+xs2 = np.linspace(c + dist, p_m + dist, 100)
+ys2 = xs2.copy() - dist
+
+xs3 = np.linspace(p_m + dist, 25, 100)
+ys3 = p_m * np.ones_like(xs3)
+
+xs = np.append(np.append(xs1, xs2), xs3)
+ys = np.append(np.append(ys1, ys2), ys3)
+
+plt.figure(figsize=[8,8])
+
+plt.plot(xs, ys, label=r"$p'_1(p_2)$")
+
+y_equals_x_xs = np.linspace(0, 25, 100)
+y_equals_x_ys = y_equals_x_xs.copy()
+
+plt.plot(y_equals_x_xs, y_equals_x_ys, label=r"$p_1 = p_2$")
+
+plt.vlines(c, 0, c, linestyle="dashed")
+plt.vlines(p_m, 0, p_m, linestyle="dashed")
+plt.hlines(p_m, 0, p_m, linestyle="dashed")
+
+plt.text(2, 6.5, r"$p'_1(p_2)$", size=16)
+plt.text(17, 20, r"$p_1 = p_2$", size=16)
+
+plt.xlim([0,22])
+plt.ylim([0,22])
+plt.xlabel(r"$p_2$", size=16)
+plt.ylabel(r"$p_1$", size=16)
+plt.xticks([c, p_m], [r"$c$", r"$p_m$"], size=14)
+plt.yticks([c, p_m], [r"$c$", r"$p_m$"], size=14)
+plt.legend();
+```
+
+Because firm 2 has the same marginal cost $c$ as firm 1, its reaction function $p'_2(p_1)$ is symmetrical to firm 1's about the line $p_1 = p_2$:
+
+[Following image has line graphs for price response functions between two firms]
+
+```python
+p_m = 18
+c = 6
+dist = 0.4 # the distance from p_1 = p_2 to p'_1(p_2)
+
+xs1 = np.linspace(0, c, 100)
+ys1 = c * np.ones_like(xs1)
+
+xs2 = np.linspace(c + dist, p_m + dist, 100)
+ys2 = xs2.copy() - dist
+
+xs3 = np.linspace(p_m + dist, 25, 100)
+ys3 = p_m * np.ones_like(xs3)
+
+xs_1 = np.append(np.append(xs1, xs2), xs3)
+ys_1 = np.append(np.append(ys1, ys2), ys3)
+
+ys1 = np.linspace(0, c, 100)
+xs1 = c * np.ones_like(xs1)
+
+ys2 = np.linspace(c + dist, p_m + dist, 100)
+xs2 = xs2.copy() - dist
+
+ys3 = np.linspace(p_m + dist, 25, 100)
+xs3 = p_m * np.ones_like(xs3)
+
+xs_2 = np.append(np.append(xs1, xs2), xs3)
+ys_2 = np.append(np.append(ys1, ys2), ys3)
+
+plt.figure(figsize=[8,8])
+
+plt.plot(xs_1, ys_1, label=r"$p'_1(p_2)$")
+plt.plot(xs_2, ys_2, label=r"$p'_2(p_1)$")
+
+y_equals_x_xs = np.linspace(0, 25, 100)
+y_equals_x_ys = y_equals_x_xs.copy()
+
+plt.plot(y_equals_x_xs, y_equals_x_ys, label=r"$p_1 = p_2$")
+
+plt.vlines(p_m, 0, p_m, linestyle="dashed")
+plt.hlines(p_m, 0, p_m, linestyle="dashed")
+
+plt.text(2, 6.5, r"$p'_1(p_2)$", size=16)
+plt.text(6.5, 2, r"$p'_2(p_1)$", size=16)
+plt.text(18.2, 21, r"$p_1 = p_2$", size=16)
+
+plt.xlim([0,22])
+plt.ylim([0,22])
+plt.xlabel(r"$p_2$", size=16)
+plt.ylabel(r"$p_1$", size=16)
+plt.xticks([c, p_m], [r"$c$", r"$p_m$"], size=14)
+plt.yticks([c, p_m], [r"$c$", r"$p_m$"], size=14)
+plt.legend();
+```
+
+These two strategies form a Nash equilibrium because neither firm can increase profits by changing their own strategy unilaterally. The equilibrium occurs where $p_1 = p'_1(p_2)$ and $p_2 = p'_2(p_1)$, at the intersection of the two reaction curves. Notably, this means that the Bertrand equilibrium occurs when both firms are producing _at marginal cost_. 
+
+This makes intuitive sense: say that the two firms both set equal prices at a price above $c$ where they split demand equally. Then both firms have incentive to reduce their price slightly and take the other half of the market share from their competitor. Thus, both firms are tempted to lower prices as much as possible, but lowering below the level of marginal cost makes no sense because then they're operating at a loss. Thus, both firms sell at the price level $c$.
+
+## Implications
+
+The Bertrand model implies that even a duopoly in a market is enough to push prices down to the level of perfect competition. It does, however, rely on some serious assumptions. For example, there are many reasons why consumers might not buy the lowest-priced item (e.g. non-price competition, search costs). When these factors are included in the Bertrand model, the same result is no longer reached. It also ignores the fact that firms may not be able to supply the entire market demand; including these capacity constraints in the model can result in the system having no Nash equilibrium. Lastly, the Bertrand model demonstrates big incentives to cooperate and raise prices to the monopoly level; however, this state is not a Nash equilibrium, and in fact, the only Nash equilibrium of this model is the non-cooperative one with prices at marginal cost.
+
+## Applying Bertrand
+
+Now that we have derived the Bertrand equilibrium, let's apply it to a problem. Consider the Coke-Pepsi duopoly we mentioned above. Suppose that the only product in the soft-drink market is the 12-oz. can, that the market demand for cans is given by $P = -0.05 Q + 5.05$, and that the marginal cost for Coke and Pepsi is constant at $c = 0.25$. To find the equilibrium price for Coke based in it's belief that Pepsi will sell at $p_2 = 1$, we need to start by finding the monopoly price level $p_m$; recall from Cournot that this occurs when the marginal revenue curve of the market demand intersects the marginal cost. The marginal revenue is $r(q) = -0.1 q + 5.05$:
+
+[Following image has line graphs for Demand, Marginal Revenue and Cost]
+
+```python
+P_fn = lambda x: -0.05 * x + 5.05
+r_fn = lambda x: 2 * P_fn(x) - P_fn(0)
+Qs = np.linspace(-10, 1000, 1000)
+Ps = P_fn(Qs)
+rs = r_fn(Qs)
+
+plt.figure(figsize=[7,7])
+plt.plot(Qs, Ps, label=r"$P(Q)$")
+plt.plot(Qs, rs, label=r"$r(Q)$")
+plt.hlines(.25, -10, 150, color="r", label=r"$c$")
+plt.xlim([0, 110])
+plt.ylim([0, 5.5])
+plt.xlabel(r"Quantity $Q$", size=16)
+plt.ylabel(r"Price $P$", size=16)
+plt.legend();
+```
+
+Using SymPy, we can find the quantity $q$ at which $r(q) = c$. This value, denoted $q_m$, is the monopoly quantity.
+
+```python
+c = 0.25
+q = sympy.Symbol("q")
+r = -.1 * q + 5.05
+
+q_m = solve(r, c)
+q_m
+```
+
+The monopoly price $p_m$ is the price from the market demand curve that this level of output:
+
+```python
+Q = sympy.Symbol("Q")
+P = -.05 * Q + 5.05
+
+p_m = P.subs(Q, q_m)
+p_m
+```
+
+Now that we have found $p_m$, we can use this to construct Coke's reaction function $p'_1(p_2)$ to Pepsi's choice of price. Assuming Coke selects $h=0.1$ (that is, Coke will sell at \$0.10 below Pepsi as long as they operate at a profit), the formula for $p'_1$ is
+
+$$
+p'_1(p_2) = \begin{cases}
+0.25 & \text{if } p_2 < 0.25 + 0.1 \\
+p_2 - 0.1 & \text{if } 0.25 + 0.1 \le p_2 < 2.65 + 0.1 \\
+2.65 & \text{otherwise}
+\end{cases}
+$$
+
+[Following image has piecewise line graphs for how one firm reacts to anothers price setting]
+
+```python
+c = 0.25
+def p1_fn(p_2, h):
+    if p_2 < c + h:
+        return c
+    elif c + h <= p_2 < p_m + h:
+        return p_2 - h
+    else:
+        return p_m
+
+p1_fn = np.vectorize(p1_fn)
+
+xs = np.linspace(-1, 4, 1000)
+ys = xs.copy()
+p1s =  p1_fn(xs, .1)
+
+plt.figure(figsize=[7,7])
+plt.plot(xs, p1s, label=r"$p'_1(p_2)$")
+plt.plot(xs, ys, label=r"$p_1 = p_2$")
+plt.hlines(c, 0, 5, color="r", label=r"$c$")
+plt.vlines(c, 0, 5, color="r")
+plt.hlines(p_m, 0, 5, color="g", label=r"$p_m$")
+plt.vlines(p_m, 0, 5, color="g")
+plt.xlim([0,3])
+plt.ylim([0,3])
+plt.xlabel(r"$p_2$", size=16)
+plt.ylabel(r"$p_1$", size=16)
+plt.legend();
+```
+
+Finally, to find Coke's selling price, we find $p'_1(1)$, since Coke believes Pepsi will sell at \$1.
+
+```python
+c = 0.25
+h = 0.1
+p_2 = sympy.Symbol("p_2")
+p_1_prime = sympy.Piecewise(
+    (c, p_2 < c + h),
+    (p_2 - h, p_2 < p_m + h),
+    (p_m, True)
+)
+
+p_1_prime.subs(p_2, 1)
+```
+
+Thus, if Coke believes that Pepsi will sell cans at \$1, it should sell at \$0.90. This should make intuitive sense: we showed that $p'_1(p_2)$ was below the line $p_1=p_2$ by a vertical distance of $h=0.1$, so it makes sense that Coke would sell at \$0.10 below Pepsi. If Coke had believed that Pepsi was going to sell at, say, \$2.70, then it would have been better for them to sell at the monopoly price level $p_m = 2.65$. If Pepsi was selling below margin cost, at \$0.20 maybe, then Coke's best bet would have been to sell at $c = 0.25$, although they would have sold 0 units of output because consumers buy from the lowest-priced vendor.
+

data/F24Textbook_MD/07-game-theory/cournot.md

@@ -0,0 +1,333 @@
+---
+title: cournot
+type: textbook
+source_path: content/07-game-theory/cournot.ipynb
+chapter: 7
+---
+
+```python
+from datascience import *
+import sympy
+solve = lambda x,y: sympy.solve(x-y)[0] if len(sympy.solve(x-y))==1 else "Not Single Solution"
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+import datetime as dt
+import warnings
+warnings.simplefilter("ignore")
+%matplotlib inline
+```
+
+# Cournot Competition
+
+One model of understanding oligopolies comes in Cournot competition, named for Aontoine Cournot who first proposed it. Cournot competition is a model describing a market in which firms compete by changing their output. In Cournot competition, there are a fixed number of firms in a market that produce the same product. Firms do not collude but have market power (i.e. each firm’s output decisions affect the price of the good). Each firm knows the number of firms in the market and has its own cost function that it uses to determine its level of output.
+
+OPEC is a good example of a Cournot oligopoly: its participants affect prices by changing their output. OPEC also demonstrates a flaw in the reasoning behind Cournot competition: the equilibrium state of a Cournot oligopoly suggests that collusion by market participants is the rational policy, but in reality game theory shows us this cannot be the “true” equilibrium because cartel members undercut one another in a bid for market share.
+
+## Cournot Profit Functions
+For the purposes of this class, we will be analyzing the case of Cournot duopoly (i.e. when there are only 2 firms in a market). Throughout the course we will make these assumptions about the market: both firms have to follow a joint linear price function (meaning the market price is determined only by the quantity produced of both firms) and both firms have an equal constant marginal cost curve. To put this formally, $P=P(Q)=P(q_1+q_2)=m(q_1+q_2)+b$ (where $m$ and $b$ are parameters for the slope and intercept of the price functions). Costs for firm 1 can be represented as $C_1=cq_1$ and costs for firm 2 can be represented as $C_2=cq_2$. To find the equilibrium of this game we will need to set up the profit functions for both firms. Starting with firm 1 we can put the last two equations together to get:
+
+$$
+\begin{equation} \label{eq1}
+\begin{split}
+\pi_1 & =Pq_1-C_1 \\
+ & =(m(q_1+q_2)+b)q_1-cq_1 \\
+ & =mq_1^2+mq_1q_2+bq_1 -cq_1
+\end{split}
+\end{equation}
+$$
+
+Firm 2 follows a similar profit function:
+
+$$
+\begin{align*}
+\pi_2 & =Pq_2-C_2\\
+ & =mq_2^2+mq_1q_2+bq_2 -cq_2   
+\end{align*}
+$$
+
+## Best Response Functions
+Similar to how in the utility unit individuals seek to maximize utility, in Cournot firms seek to maximize profit. So we will be using the same mathematical tool we learned last week (partial derivatives) to derive the equilibrium of this game. Specifically we will be solving for a $q_1^{*}$ that satisfies $ \underset{q_1}{\mathrm{argmax}}\ \pi_1 \ \textrm{or} \ \underset{q_1}{\mathrm{argmax}}\ (mq_1^2+mq_1q_2+bq_1 -cq_1)$. In english, this means we will be finding the value (or values) of $q_1$ that maximize the profit function for player 1. We will also do the same thing for player 2. Starting with player 1, let's take the partial derivative with respect to $q_1$ and set that equation equal to 0. We can then solve that equation to obtain $q_1^{*}$. 
+
+$$
+\begin{align*}
+   \frac{\partial{\pi_1}}{\partial{q_1}}= 2mq_1 + mq_2+b - c \\
+   2mq_1 + mq_2+b - c = 0\\
+  q_1^{*}= \frac{c-mq_2-b}{2m}
+\end{align*}
+ \
+$$
+This equation for $q_1$ is called a best response function because it tells us player 1's optimal output for every possible output player 2 can choose. Now, in order to get the equilibrium, we need to find player 2's best response function. We will use the same approach to do this (i.e., we will solve for a $q_2^{*}$ that satisfies $\underset{q_2}{\mathrm{argmax}}\ \pi_2 \ \textrm{or} \ \underset{q_2}{\mathrm{argmax}}\ mq_2^2+mq_1q_2+bq_2 -cq_2$ ).
+ 
+$$
+ \begin{align*}
+   \frac{\partial{\pi_2}}{\partial{q_2}}= 2mq_2 + mq_1+b - c \\ 
+   2mq_2 + mq_1+b - c = 0\\
+   q_2^{*} = \frac{c-mq_1-b}{2m}
+\end{align*}
+$$
+
+If $q_2$ was fixed at a certain price and we were to graph firm 1's best response equation, it would look something like this:
+
+[Following image has line graphs for downward sloping market demand and marginal revenue functions]
+
+```python
+m, b = -0.5, 9
+q_2 = 4
+c = 3
+D_fn = lambda x: m * x + b + 2
+P = lambda x: D_fn(x + q_2)
+r_1_fn = lambda x: 2 * m * x + m * q_2 + b + 2
+r_1_inv = lambda x: (x - m * q_2 - b - 2) / 2 / m
+
+q_1 = np.linspace(0, 25, 1000)
+D = D_fn(q_1)
+d_1 = P(q_1)
+r_1 = r_1_fn(q_1)
+
+q_1_prime = r_1_inv(c)
+
+plt.figure(figsize=[8,8])
+
+# demand
+plt.plot(q_1, D, label=r"Market Demand, $D$")
+plt.text(5, b, r"$D$", size=16)
+
+
+
+# marginal revenue
+plt.plot(q_1, r_1, label=r"Marginal Revenue of Firm 1, $r_1$")
+plt.text(5, b - 4.5, r"$r_1$", size=16)
+
+# marginal cost
+plt.plot(q_1, c * np.ones_like(q_1), label=r"Marginal Cost, $c$")
+plt.text(20, 3.2, r"$c$", size=16)
+
+# optimum quantity
+plt.vlines(q_1_prime, 0, 3, linestyles="dashed")
+
+
+
+plt.xlim([0,22])
+plt.ylim([0,12])
+plt.xticks([r_1_inv(c)], [r"$q_1^*$"], size=14)
+plt.yticks([P(0)], [r"$P(q_2)$"], size=14)
+plt.xlabel("Quantity", size=16)
+plt.ylabel("Price", size=16)
+plt.legend();
+```
+
+This may make intuitive sense as if you recall from the demand and supply chapters, firms seek to produce where marginal revenue equals marginal cost. The partial derivative we took before did that automatically. We can verify this with the following calculation:  
+
+$$
+\begin{align*}
+    MR=MC  \\
+    MR-MC=0  \\
+    \frac{\partial}{\partial{q_1}} (\textrm{Revenue - Cost}) = 0 \\
+    \frac{\partial}{\partial{q_1}} ((m(q_1+q_2)+b)q_1-cq_1) = 0 \\
+    2mq_1 + mq_2+b - c = 0 
+\end{align*}
+$$
+
+However, this graph assumes a fixed value for $q_2$. Let's try varying $q_2$ and see what happens.
+
+[Following image has line graphs for downward sloping market demand and marginal revenue functions]
+
+```python
+m, b = -0.5, 9
+q_2 = 0
+c = 3
+D_fn = lambda x: m * x + b + 2
+P = lambda x: D_fn(x + q_2)
+r_1_fn = lambda x: 2 * m * x + m * q_2 + b + 2
+r_1_inv = lambda x: (x - m * q_2 - b - 2) / 2 / m
+
+q_1 = np.linspace(0, 25, 1000)
+D = D_fn(q_1)
+d_1 = P(q_1)
+r_1 = r_1_fn(q_1)
+
+q_1_prime = r_1_inv(c)
+
+plt.figure(figsize=[8,8])
+
+# demand
+plt.plot(q_1, D, label=r"Market Demand, $D$")
+plt.text(5, b, r"$D$", size=16)
+
+
+# marginal revenue
+plt.plot(q_1, r_1, label=r"Marginal Revenue of Firm 1 for $q_2=0$, $r_1$")
+plt.text(5, b - 2.5, r"$r_1$", size=16)
+
+# case when q_2 = q_c
+m, b = -0.5, 9
+q_2 = 16
+c = 3
+D_fn = lambda x: m * x + b + 2
+P = lambda x: D_fn(x + q_2)
+r_1_fn = lambda x: 2 * m * x + m * q_2 + b + 2
+r_1_inv = lambda x: (x - m * q_2 - b - 2) / 2 / m
+
+q_1 = np.linspace(0, 25, 1000)
+D = D_fn(q_1)
+d_1 = P(q_1)
+r_1 = r_1_fn(q_1)
+
+
+# marginal revenue
+plt.plot(q_1, r_1, label=r"Marginal Revenue of Firm 1 for $q_2=q_m$, $r_1$")
+plt.text(2.5, 0.8, r"$r_1$", size=16)
+
+# marginal cost
+plt.plot(q_1, c * np.ones_like(q_1), label=r"Marginal Cost, $c$")
+plt.text(20, 3.2, r"$c$", size=16)
+
+
+# q'_1(0)
+plt.vlines(r_1_inv(-5), 0, 3, linestyles="dashed")
+
+plt.xlim([0,22])
+plt.ylim([0,12])
+plt.xticks([r_1_inv(-5), 0], [r"$q_1^*(0) = q_m$", r"$q_1^*(q_m)$"], size=14)
+plt.yticks([], [], size=14)
+plt.xlabel("Quantity", size=16)
+plt.ylabel("Price", size=16)
+plt.legend();
+```
+
+The orange marginal revenue curve represents a scenario where Firm 2 produces so little that Firm 1 can overtake the market and become a monopoly. The green marginal revenue curve is a scenario where Firm 2 produces so much that it is too costly for Firm 1 to remain in this market, causing Firm 1's optimal output to become 0. 
+
+Let's now try to solve for the Nash Equilibrium of this game.
+
+## Cournot Equilibrium
+Recall that a Nash Equilibrium is where both the players are giving the best response to each other's actions. Graphically, this is where the best response curves intersect. 
+
+[Following image has line graphs for the intersecting lines of response functions between two firms]
+
+```python
+q_m = r_1_inv(-5)
+q_c = D_fn(-10)
+
+p1 = (0, q_m)
+p2 = (q_c, 0)
+
+slope = (p2[1] - p1[1]) / (p2[0]- p1[0])
+intercept = p1[1] - slope * p1[0]
+
+xs = np.linspace(0, 25, 1000)
+ys1 = slope * xs + intercept
+ys2 = (xs - intercept) / slope
+
+plt.figure(figsize=[8,8])
+
+plt.plot(xs, ys1, label=r"$q'_1$")
+plt.plot(xs, ys2, label=r"$q'_2$")
+plt.text(13, intercept - 6.3, r"$q_1^*(q_2)$", size=16)
+plt.text(3, intercept + 2.5, r"$q_2^*(q_1)$", size=16)
+
+x_star = - (slope + 1) * intercept / (slope**2 - 1)
+y_star = slope * x_star + intercept
+plt.vlines(x_star, 0, y_star, linestyle="dashed")
+plt.hlines(y_star, 0, x_star, linestyle="dashed")
+
+plt.xlim([0,22])
+plt.ylim([0,12])
+plt.xticks([x_star], [r"$q_2^*$"], size=14)
+plt.yticks([y_star], [r"$q_1^*$"], size=14);
+```
+
+In this class, you will use Python to find that intersection. However, for future classes, it may be useful to see how you can find the intersection algebraically. Here's the equation we must solve:
+
+$$
+\begin{align*}
+    q_1=\frac{c-b-m(\frac{c-mq_1-b}{2m})}{2m}
+\end{align*}
+\
+$$
+
+To find player 1's equilibrium strategy, we solve for $q_1$. 
+
+$$
+\begin{align*}
+    q_1=\frac{c-b-m(\frac{c-mq_1-b}{2m})}{2m} \\ 
+    2mq_1 = c-b-m(\frac{c-mq_1-b}{2m}) \\
+    2mq_1 = c-b-\frac{c-mq_1-b}{2}\\
+    2mq_1 - \frac{mq_1}{2} = c - \frac{c}{2} -b +\frac{b}{2} \\
+    \frac{3mq_1}{2} = \frac{c-b}{2} \\ 
+    3mq_1 = c-b \\
+    q_1^{*} = \frac{c-b}{3m}
+\end{align*}
+\
+$$
+
+Phew, that was a lot of math. However, we are not quite done yet - we still need to find player 2's optimal output. The process for doing this is fairly similar to the process for finding player 1's optimal output, as can be seen below. 
+
+$$
+\begin{align*}
+    q_2 = \frac{c-mq_1^{*}-b}{2m} = \frac{c-b-m(\frac{c-b}{3m})}{2m} \\
+    2mq_2 = c -\frac{c}{3} - b +\frac{b}{3} \\
+    2mq_2 = \frac{2(c-b)}{3}\\
+    q_2^{*} = q_2 = \frac{c-b}{3m}
+\end{align*}
+\
+$$
+This shows that the unique Nash Equilibrium of Cournot Duopoly is $(q_1^{*},q_2^{*}) = (\frac{c-b}{3m},\frac{c-b}{3m})$
+
+## Implications
+The Cournot model implies that output is greater in a Cournot duopoly than in a monopoly but still lower than perfect competition. Prices are also lower in a Cournot duopoly, but higher than perfect competition. Cournot equilibria are also a subset of Nash equilibria, and so the equilibrium we just derived is one from which neither player will likely deviate. As noted earlier, Cournot also indicates that members of a duopoly could form a cartel and raise profits by colluding.
+
+### Applying Cournot
+Now that we have shown how to derive the Cournot equilibrium, let’s apply this to a problem. Consider the industry of airline manufacturing: there are two main competitors, Boeing and Airbus, and for this problem, we will think of this market as a Cournot duopoly. Suppose the market demand curve is given by $P=-1.89Q+148.89$ where the price is in millions of dollars and that the marginal cost of both firms is constant at $c=100$. Solve for the Nash Equilibrium. 
+
+
+First we will want to derive both firms profit functions:
+
+$$
+\begin{align*} 
+    \pi_1 & = Pq_1 -cq_1 \\
+    \pi_1 & = (-1.89Q+148.89)q_1 - cq_1 \\
+    \pi_1 & = (-1.89(q_1+q_2)+148.89)q_1 -cq_1 \\
+    \pi_1 & = -1.89q_1^2-1.89q_1q_2+148.89q_1 - cq_1
+\end{align*}
+$$
+
+For firm 2 the profit function similarly looks like:
+
+$$
+\begin{align*}
+    \pi_2 = -1.89q_2^2-1.89q_1q_2+148.89q_2 - cq_2
+\end{align*}
+$$
+
+Now we will take the partial derivative to find the best response functions for both players. For firm 1 this looks like:
+
+$$
+\begin{align*}
+    \frac{\partial{\pi_1}}{\partial{q_1}}= -3.78q_1 - 1.89q_2+148.89 - 100 = 0\\
+    q_1 = \frac{48.89-1.89q_2}{3.78}
+\end{align*}
+\
+$$
+
+For firm 2 this looks like:
+
+$$
+\begin{align*}
+    \frac{\partial{\pi_2}}{\partial{q_2}}= -3.78q_2 - 1.89q_1+148.89 - 100 = 0\\
+    q_2 = \frac{48.89-1.89q_1}{3.78}
+\end{align*}
+$$
+
+Now while you can solve this algebraically, it takes much longer and leaves a lot of room for error, so as data scientists we will use Python to solve this problem. The code for this looks like this:
+
+```python
+q_1=sympy.Symbol("q_1") #Create a symbol for q1
+q_2=sympy.Symbol("q_2")#Create a symbol for q2
+Br_q_1 = (48.89 - 1.89*q_2)/3.78 #Create the best response function for firm 1
+Br_q_2 = (48.89 - 1.89*q_1)/3.78 #Create the best response function for firm 2
+q1_Br_2 = (48.89-3.78*q_2)/1.89 #Solve firm 2's best response function for q1
+q_1_star = solve(Br_q_1,q1_Br_2) #Use the solve function to solve the system of equations 
+q_2_star = Br_q_2.subs(q_1,q_1_star ) #Substiute in the optimal q_1_star into firm 2's best response function
+(q_1_star,q_2_star) #Nash Equilibrium
+```