my-markdown-library 0.1.0

data/F24Lec_MD/lec06/6.2-3D-utility.md

@@ -0,0 +1,287 @@
+---
+title: "6.2-3D-utility"
+type: lecture-notebook
+week: 6
+source_path: "/Users/ericvandusen/Documents/Data88E-ForTraining/F24Lec_NBs/lec06/6.2-3D-utility.ipynb"
+---
+
+<table style="width: 100%;" id="nb-header">
+    <tr style="background-color: transparent;"><td>
+        <img src="https://data-88e.github.io/assets/images/blue_text.png" width="250px" style="margin-left: 0;" />
+    </td><td>
+        <p style="text-align: right; font-size: 10pt;"><strong>Economic Models</strong>, <br>
+            Dr. Eric Van Dusen <br>
+        Akhil Venkatesh <br>
+</table>
+
+```python
+import pandas as pd
+import numpy as np
+#import chart_studio.plotly as py
+import plotly.graph_objs as go
+from plotly.offline import download_plotlyjs, init_notebook_mode, plot, iplot
+from ipywidgets import interact, interactive, fixed, interact_manual
+import ipywidgets as widgets
+from IPython.display import display, HTML
+import warnings
+warnings.filterwarnings('ignore')
+import plotly.io as pio
+pio.renderers.default = 'notebook'
+```
+
+# Utility Functions and Indifference Curves
+
+## What is Utility?
+
+When we consume a good, we assume that the good will have some impact on our total utility. Utility is a fundamental measure that helps economists model how consumers make decisions. An assumed rule in economics is that consumers will always act rationally, which translates to the assumption that consumers will always attempt to maximize their own utility. 
+
+It is important to note that utility doesn't have specified units and even the face value of utility doesn't have any meaning. *What does an apple providing 5 utility units even mean?* What is valuable, however, is that utility can be compared; if an apple provides 5 utility units and an orange provides 3 utility units, then we prefer apples to oranges.
+
+As a very simple example, say Anne has 6 dollars and she can choose to buy any combination of goods A and B. If good A costs 2 dollars and provides 5 utility units per unit of A consumed, while good B costs 3 dollars and provides 6 utility units per unit of B consumed, then Anne will buy 3 units of good A, since that maximizes her utility. 
+
+In economics, however, our models are a little more complex than that. Typically, utility is the product of the consumption of many goods; typically having a lot of one good but not another does not provide much utility. In addition, consumption of one good faces diminishing marginal returns, i.e. holding all things equal, the consumption of one additional unit of a good will provide less utility than the utility received from the previous unit. Intuitively, imagine Bob is very hungry and decides to eat slices of pizza. The first slice of pizza will bring Bob the most utility, but the 8th slice will be much less satisfying to eat.
+
+## Utility Functions
+A consumer's utility is determined by the amount of consumption from all the goods they consume. Typically, utility functions are multivariate: they take in multiple inputs (which represent the different amounts of consumption for each good, which we call a consumption bundle), and output one value, the utility. Today, we'll only look at the case where consumers can only choose between 2 goods $x_1$ and $x_2$. Hence, a utility function can be represented by: $u(x_1,x_2)$. 
+
+With that in mind, let's start graphing some utility functions!
+
+### Cobb-Douglas Utility Function
+
+Consider the following utility function across $x_1$ and $x_2$:
+
+$$u(x_1, x_2)=x_1^{\alpha}x_2^{1-\alpha}\quad\text{where } 0<\alpha<1$$
+
+This is known as the **Cobb-Douglas utility function**. To visualize this function, we'll need a 3D plot.
+
+```python
+alpha = 0.5
+def cobb_douglas(x1, x2):
+    return (x1 ** alpha) * (x2 ** (1-alpha))
+x1 = np.linspace(0,10,10)
+x2 = np.linspace(0,10,10)
+X1,X2 = np.meshgrid(x1,x2)
+z = cobb_douglas(X1,X2)
+data = [go.Surface(z=z, contours=go.surface.Contours(z=go.surface.contours.Z(show=True,usecolormap=True,highlightcolor="#42f462",project=dict(z=True))))]
+layout = go.Layout(title='Cobb-Douglas Utility Function (alpha = 0.5)',autosize=False,width=500,height=500,margin=dict(l=65,r=50,b=65,t=90),
+scene = dict(xaxis = dict(title='X1'),yaxis = dict(title=r'X2'),zaxis = dict(title='Utility'),))
+fig = go.Figure(data=data, layout=layout)
+
+plot(fig, filename="fig1.html", auto_open=False)
+display(HTML("fig1.html"))
+```
+
+## Examining the Utility Function
+
+There are 2 rules that utility functions generally follow: 
+
+- Non-negative marginal utility: the consumption of a good will not decrease the utility. Economists generally assume that 'more is better.' If the consumption of a good decreased utility, then we would consume less of a good. 
+- Diminishing marginal returns: all else equal, as consumption increases the marginal utility derived from each additional unit declines.
+
+### Non-negative Marginal Utility
+Say we are currently consuming 2 units of $x_1$ and $x_2$ each with $\alpha = \frac{1}{2}$, providing $u(2,2)=2^{0.5}2^{0.5}=2$ utility units. One additional unit of $x_1$ will provide me a higher point of utility: we can verify this result both graphically and numerically: $u(3,2)=3^{0.5}2^{0.5}\approx2.45$. Indeed, consuming one more unit of a good should increase our utility!
+
+### Marginal Utility and the Law of Diminishing Returns
+Now let's check for the second result: diminishing marginal returns. From above, we know that holding the consumption of $x_2$ constant at 2, going from 2 to 3 units of $x_1$ increases our utility by $2.45-2=0.45$. Going from 3 to 4 units of $x_1$ brings our utility to $u(4,2)=4^{0.5}2^{0.5}\approx 2.83$, an increase of $2.83-2.45=0.38$ utility units.
+
+Using calculus, we can more formally define the marginal utility of a good. Since marginal utility is the change in utility that one additional unit of consumption provides (holding all others constant), the marginal utility with respect to $x_1$ is its partial derivative: $\frac{\partial u}{\partial x_1}$. In our case:
+
+$$
+\begin{aligned}
+\textrm{Marginal Utility of } x_1: &\quad\frac{\partial u}{\partial x_1} = \frac{1}{2}x_1^{-0.5}x_2^{0.5} \\
+\textrm{Marginal Utility of } x_2: &\quad\frac{\partial u}{\partial x_2} = \frac{1}{2}x_1^{0.5}x_2^{-0.5}
+\end{aligned}
+$$
+
+Or, more generally,
+
+$$\begin{aligned}
+\textrm{Marginal Utility of } x_1: &\quad\frac{\partial u}{\partial x_1} = \alpha x_1^{\alpha-1}x_2^{1-\alpha} \\
+\textrm{Marginal Utility of } x_2: &\quad\frac{\partial u}{\partial x_2} = (1-\alpha) x_1^{\alpha}x_2^{-\alpha}
+\end{aligned}$$
+
+
+With marginal utility defined, note that both conditions can be explained using the marginal utility function $\frac{\partial u}{\partial x}$: 
+
+- Non-negative marginal utility: $\frac{\partial u}{\partial x} \geq 0$
+- Diminishing marginal returns: $\frac{\partial^2 u}{\partial x^2} < 0$
+
+## Indifference Curves
+
+Although the utility function above in 3D is cool, you'll typically find utility graphs to be in 2D with $x_1$ and $x_2$ as the axis (eliminating the utility axis). 
+
+To represent utility levels, we plot a set of indifference curves on the 2D graph. An indifference curve satisfies the property in which **any point on the curve has the exact same amount of utility**, so that consumers are _indifferent_ to any point on the curve. In our 3D plot, any point on the indifference curve has the exact same height, which represents the value of utility. If you're familar with contour plots, you can also think of indifference curves as following the same idea.
+
+```python
+alpha = 0.5
+utilities = np.arange(1, 9)
+x1_indiff_val = np.linspace(0,50,1000)
+x2_indiff_vals = []
+for u in utilities:
+    x2_indiff_vals.append(((u/(x1_indiff_val ** alpha)) ** (1/(1-alpha))))
+traces = []
+colors = ['blue', 'red','green','purple'] + ['blue', 'red','green','purple']
+for u, c, x2 in zip(utilities, colors, x2_indiff_vals):
+    traces.append(go.Scatter(
+    x = x1_indiff_val,
+    y = x2,
+    name = 'utility = ' + str(u),
+    line = dict(color = c,width = 1)))
+
+data = traces
+
+# Edit the layout
+layout = dict(title = 'Indifference Curves for the Cobb-Douglas Utility Function (alpha = ' + str(alpha) + ')',
+              xaxis = dict(title = 'X1', range = [0,10]),
+              yaxis = dict(title = 'X2', range = [0,10]),)
+
+fig = dict(data=data, layout=layout)
+
+plot(fig, filename="fig2.html", auto_open=False)
+display(HTML("fig2.html"))
+```
+
+
+
+# Budget Constraints and Utility Maximization
+
+In this section, we will assume that $\alpha = 0.5$ (i.e. the utility function is: $u(x_1, x_2) = x_1^{0.5}x_2^{0.5}$).
+
+Now we introduce the concept of money into our model. Consumers face a budget constraint when choosing to maximize their utility. Given an income $M$ and prices $p_1$ for good $x_1$ and $p_2$ for good $x_2$, the consumer can at most spend up to $M$ for both goods:
+
+$$M \geq p_1x_1 + p_2x_2$$
+
+Since goods will always bring non-negative marginal utility, consumers will try to consume as many goods as they can. Hence, we can rewrite the budget constraint as an equality instead (since if they have more income leftover, they will use it to buy more goods).
+
+$$M = p_1x_1 + p_2x_2$$
+
+This means that any bundle of goods $(x_1,x_2)$ that consumers choose to consume will adhere to the equality above. What does this mean on our graph? Let's examine the indifference curve plots, assuming that $M = 32$, and $p_1 =2$ and $p_2 = 4$.
+
+```python
+M = 32
+p_1 = 2
+p_2 = 4
+
+# Plot default indifference curves
+utilities = np.arange(1, 9)
+x1_indiff_val = np.linspace(0,50,1000)
+x2_indiff_vals = []
+for u in utilities:
+    x2_indiff_vals.append(((u/(x1_indiff_val ** (1/2))) ** (2)))
+traces = []
+colors = ['blue', 'red','green','purple'] + ['blue', 'red','green','purple']
+for u,c,x2 in zip(utilities,colors,x2_indiff_vals):
+    traces.append(go.Scatter(
+    x = x1_indiff_val,
+    y = x2,
+    name = 'utility = ' + str(u),
+    line = dict(color = c,width = 1)))
+    
+# for i in range(len(traces) - 4):
+#     del traces[-1] # This is a hacky method to not continually append to TRACES upon an update from the slider.
+x2_bc_val = (M - (p_1*x1_indiff_val))/p_2
+traces.append(go.Scatter(
+    x = x1_indiff_val,
+    y = x2_bc_val,
+    name = 'Budget Constraint',
+    line = dict(color = 'black',width = 1,dash="dot")))
+data = traces
+layout = dict(title = 'Budget Constraint and Indifference Curves for the Cobb-Douglas Utility Function (alpha = 0.5)',
+              xaxis = dict(title = 'X1', range = [0,18]),
+              yaxis = dict(title = 'X2', range = [0,10]),)
+fig = dict(data=data, layout=layout)
+
+plot(fig, filename="fig3.html", auto_open=False)
+display(HTML("fig3.html"))
+```
+
+The budget constraint is like a possibilities curve: moving up or down the constraint means gaining more of one good while sacrificing the other.
+
+Let's take a look at what this budget constraint means. Because of the budget constraint, any bundle of goods $(x_1,x_2)$ that consumers ultimately decide to consume will lie on the budget constraint line. Adhering to this constraint where $M=32, p_1 = 2, p_2 = 4$, we can see that consumers will be able to achieve 2 units of utility, and can also achieve 4 units of utility. But what is the maximum amount of utility that consumers can achieve? 
+
+Notice an interesting property about indifference curves: **the utility level of the indifference curves gets larger as we move up and to the right.** Hence, the maximizing amount of utility in this budget constraint is the rightmost indifference curve that still touches the budget constraint line. In fact, it'll only 'touch' (and not intersect) the budget constraint and be tangential to it.
+
+```python
+M = 32
+p_1 = 2
+p_2 = 4
+
+# Plot default indifference curves
+utilities = np.arange(1, 9)
+x1_indiff_val = np.linspace(0,50,1000)
+x2_indiff_vals = []
+for u in utilities:
+    x2_indiff_vals.append(((u/(x1_indiff_val ** (1/2))) ** (2)))
+traces = []
+colors = ['blue', 'red','green','purple'] + ['blue', 'red','green','purple']
+for u,c,x2 in zip(utilities,colors,x2_indiff_vals):
+    traces.append(go.Scatter(
+    x = x1_indiff_val,
+    y = x2,
+    name = 'utility = ' + str(u),
+    line = dict(color = c,width = 1)))
+
+# PLOT BC
+x2_bc_val = (M - (p_1*x1_indiff_val))/p_2
+traces.append(go.Scatter(
+    x = x1_indiff_val,
+    y = x2_bc_val,
+    name = 'Budget Constraint',
+    line = dict(color = 'black',width = 1,dash="dot")))
+
+
+# PLOT MAX UTIL INDIFF CURVE
+max_utility = ((1/2*M/p_1) ** (1/2)) * ((1/2*M/p_2) ** (1/2))
+x2_max_util = (max_utility/(x1_indiff_val ** (1/2))) ** 2
+x2_max_util = (max_utility/(x1_indiff_val ** (1/2))) ** 2
+traces.append(go.Scatter(
+    x = x1_indiff_val,
+    y = x2_max_util,
+    name = 'Maximized Utility = ' + str(round(max_utility, 2)),
+    line = dict(color = 'black',width = 2)))
+data = traces
+
+layout = dict(title = 'Budget Constraint and Indifference Curves for the Cobb-Douglas Utility Function (alpha = 0.5)',
+              xaxis = dict(title = 'X1', range = [0,20]),
+              yaxis = dict(title = 'X2', range = [0,15]),)
+fig = dict(data=data, layout=layout)
+
+plot(fig, filename="fig4.html", auto_open=False)
+display(HTML("fig4.html"))
+```
+
+Notice that as the price of one good increases, the indifference curve that represents the maximum attainable utility shifts towards the left (i.e. the max utility decreases). Intuitively, this makes sense. As the price of one good increases, consumers have to make adjustments to their consumption bundles and buy less of one, or both, goods. Hence, their maximum utility will decrease.
+
+Let's visualize the budget constraint in 3D where $M=30, p_1=3, p_2=3$. Here, any point along the curve in which the 2 planes intersect represents an amount of utility in which the budget constraint holds true (i.e. where we've spent all our income). The utility maximizing quantity is a point on this intersecting curve at which the utility level is the highest.
+
+```python
+def cobb_douglas(x1, x2):
+    return (x1 ** (1/2)) * (x2 ** (1/2))
+x1 = np.linspace(0,10,10)
+x2 = np.linspace(0,10,10)
+X1,X2 = np.meshgrid(x1,x2)
+z = cobb_douglas(X1,X2)
+
+def budget_constraint(x1, x2):
+    return 10000*(3*x1 + 3*x2 - 30) # We multiply this by 10000 to get a very steep plane, which should be similar to the actual BC, a vertical plane.
+
+z2 = budget_constraint(X1, X2)
+
+data = [go.Surface(
+    z=z, contours=go.surface.Contours(z=go.surface.contours.Z(show=True,usecolormap=True,highlightcolor="#42f462",
+                                                              project=dict(z=True))), name="Cobb-Douglas Utility Function"),
+       go.Surface(
+   z=z2, contours=go.surface.Contours(z=go.surface.contours.Z(show=True,usecolormap=False,
+                              highlightcolor="#42f462",project=dict(z=True))),showscale=False, colorscale="balance", name="Budget Constraint")]
+layout = go.Layout(
+    title='Cobb-Douglas Utility Function with Budget Constraint', autosize=False,width=500, height=500, margin=dict(l=65,r=50,b=65,t=90),
+    scene = dict(xaxis = dict(title='X1', range = [0,10]), yaxis = dict(title='X2'),
+    zaxis = dict(title = 'Utility', nticks=4, range = [0,10],)))
+fig = go.Figure(data=data, layout=layout)
+
+plot(fig, filename="fig5.html", auto_open=False)
+display(HTML("fig5.html"))
+```
+
+
+

data/F24Lec_MD/lec06/6.3-QuantEcon-Optimization.md

@@ -0,0 +1,399 @@
+---
+title: "6.3-QuantEcon-Optimization"
+type: lecture-notebook
+week: 6
+source_path: "/Users/ericvandusen/Documents/Data88E-ForTraining/F24Lec_NBs/lec06/6.3-QuantEcon-Optimization.ipynb"
+---
+
+# Optimization from QuantEcon
+
+This is a Lecture written by the QuantEcon project
+https://datascience.quantecon.org/scientific/optimization.html
+
+
+
+**Prerequisites**
+
+- [Introduction to Numpy](https://datascience.quantecon.org/numpy_arrays.html)  
+- [Applied Linear Algebra](https://datascience.quantecon.org/applied_linalg.html)  
+
+
+**Outcomes**
+
+- Perform optimization by hand using derivatives  
+- Understand ideas from gradient descent
+
+```python
+import numpy as np
+import matplotlib.pyplot as plt
+%matplotlib inline
+```
+
+## What is Optimization?
+
+Optimization is the branch of mathematics focused on finding extreme values (max or min) of
+functions.
+
+Optimization tools will appear in many places throughout this course, including:
+
+- Building economic models in which individuals make decisions that maximize their utility.  
+- Building statistical models and maximizing the fit of these models by optimizing certain fit
+  functions.  
+
+
+In this lecture, we will focus mostly on the first to limit the moving pieces, but in other lectures, we’ll discuss the second in detail.
+
+### Derivatives and Optima
+
+Here, we revisit some of the theory that you have already learned in your calculus class.
+
+Consider function $ f(x) $ which maps a number into another number. We can say that any point
+where $ f'(x) = 0 $ is a local extremum of $ f $.
+
+Let’s work through an example. Consider the function
+
+$$
+f(x) = x^4 - 3 x^2
+$$
+
+Its derivative is given by
+
+$$
+\frac{\partial f}{\partial x} = 4 x^3 - 6 x
+$$
+
+Let’s plot the function and its derivative to pick out the local extremum by hand.
+
+```python
+def f(x):
+    return x**4 - 3*x**2
+
+
+def fp(x):
+    return 4*x**3 - 6*x
+
+# Create 100 evenly spaced points between -2 and 2
+x = np.linspace(-2., 2., 100)
+
+# Evaluate the functions at x values
+fx = f(x)
+fpx = fp(x)
+
+# Create plot
+fig, ax = plt.subplots(1, 2)
+
+ax[0].plot(x, fx)
+ax[0].set_title("Function")
+
+ax[1].plot(x, fpx)
+ax[1].hlines(0.0, -2.5, 2.5, color="k", linestyle="--")
+ax[1].set_title("Derivative")
+
+for _ax in ax:
+    _ax.spines["right"].set_visible(False)
+    _ax.spines["top"].set_visible(False)
+```
+
+If you stare at this picture, you can probably determine the the local maximum is at
+$ x = 0 $ and the local minima at $ x \approx -1 $ and $ x \approx 1 $.
+
+To properly determine the minima and maxima, we find the solutions to $ f'(x) = 0 $ below:
+
+$$
+f'(x) = 4 x^3 - 6 x = 0
+$$
+
+$$
+\rightarrow x = \left\{0, \frac{\sqrt{6}}{2}, \frac{-\sqrt{6}}{2} \right\}
+$$
+
+Let’s check whether we can get the same answers with Python! To do this, we import a new
+package that we haven’t seen yet.
+
+```python
+import scipy.optimize as opt
+```
+
+Then using the function definitions from earlier, we search for the minimum and maximum values.
+
+```python
+# For a scalar problem, we give it the function and the bounds between
+# which we want to search
+neg_min = opt.minimize_scalar(f, [-2, -0.5])
+pos_min = opt.minimize_scalar(f, [0.5, 2.0])
+print("The negative minimum is: \n", neg_min)
+print("The positive minimum is: \n", pos_min)
+```
+
+The scipy optimize package only has functions that find minimums… You might be wondering, then, how we
+will verify our maximum value.
+
+It turns out that finding the maximum is equivalent to simply finding the minimum of the negative function.
+
+```python
+# Create a function that evaluates to negative f
+def neg_f(x):
+    return -f(x)
+
+max_out = opt.minimize_scalar(neg_f, [-0.35, 0.35])
+print("The maximum is: \n", max_out)
+```
+
+We won’t dive into the details of optimization algorithms in this lecture, but we’ll impart some brief
+intuition to help you understand the types of problems these algorithms are good at solving and
+the types of problems they will struggle with:
+
+The general intuition is that when you’re finding a maximum, an algorithm takes a step
+in the direction of the derivative… (Conversely, to find a minimum, the algorithm takes a step opposite the direction of the derivative.)
+This requires the function to be relatively smooth and continuous. The algorithm also has an easier time if there is only one (or very few) extremum to be found…
+
+For minimization, you can imagine the algorithm as a marble in a bowl.
+
+The marble will keep rolling down the slope of the bowl until it finds the bottom.
+
+It may overshoot, but once it hits the slope on the other side, it will continue to roll back
+and forth until it comes to rest.
+
+Thus, when deciding whether numerical optimization is an effective method for a
+particular problem, you could try visualizing the function to determine whether a marble
+would be able to come to rest at the extreme values you are looking for.
+
+### Application: Consumer Theory
+
+A common use of maximization in economics is to model
+optimal consumption decisions [https://en.wikipedia.org/wiki/Consumer_choice](https://en.wikipedia.org/wiki/Consumer_choice).
+
+#### Preferences and Utility Functions
+
+To summarize introductory economics, take a set of
+[preferences](https://en.wikipedia.org/wiki/Preference_%28economics%29) of consumers over “bundles”
+of goods (e.g. 2 apples and 3 oranges is preferred to 3 apples and 2 oranges, or a 100% chance to
+win $ 1 $ dollar is preferred to a 50% chance to win $ 2.10 $ dollars).
+
+Under certain assumptions, you rationalize the preferences as a utility function over the different
+goods (always remembering that the utility is simply a tool to order preferences and the numbers are
+usually not meaningful themselves).
+
+For example, consider a utility function over bundles of bananas (B) and apples (A)
+
+$$
+U(B, A) = B^{\alpha}A^{1-\alpha}
+$$
+
+Where $ \alpha \in [0,1] $.
+
+First, let’s take a look at this particular utility function.
+
+```python
+def U(A, B, alpha=1/3):
+    return B**alpha * A**(1-alpha)
+
+fig, ax = plt.subplots()
+B = 1.5
+A = np.linspace(1, 10, 100)
+ax.plot(A, U(A, B))
+ax.set_xlabel("A")
+ax.set_ylabel("U(B=1.5, A)")
+```
+
+We note that
+
+- $ U(B,1) $ is always higher with more B, hence, consuming more bananas has a
+  : positive marginal utility  i.e. $ \frac{d U(B,1)}{d B} > 0 $.  
+- The more bananas we consume, the smaller the change in marginal utility, i.e.
+  $ \frac{d^2 U(B,1)}{d B^2} < 0 $.  
+
+
+If we plot both the $ B $ and the $ A $, we can see how the utility changes with different
+bundles.
+
+```python
+fig, ax = plt.subplots()
+B = np.linspace(1, 20, 100).reshape((100, 1))
+contours = ax.contourf(A, B.flatten(), U(A, B))
+fig.colorbar(contours)
+ax.set_xlabel("A")
+ax.set_ylabel("B")
+ax.set_title("U(A,B)")
+```
+
+We can find the bundles between which the consumer would be indifferent by fixing a
+utility $ \bar{U} $ and by determining all combinations of $ A $ and $ B $ where
+$ \bar{U} = U(B, A) $.
+
+In this example, we can implement this calculation by letting $ B $ be the variable on the
+x-axis and solving for $ A(\bar{U}, B) $
+
+$$
+A(B, \bar{U}) = U^{\frac{1}{1-\alpha}}B^{\frac{-\alpha}{1-\alpha}}
+$$
+
+```python
+def A_indifference(B, ubar, alpha=1/3):
+    return ubar**(1/(1-alpha)) * B**(-alpha/(1-alpha))
+
+def plot_indifference_curves(ax, alpha=1/3):
+    ubar = np.arange(1, 11, 2)
+    ax.plot(B, A_indifference(B, ubar, alpha))
+    ax.legend([r"$\bar{U}$" + " = {}".format(i) for i in ubar])
+    ax.set_xlabel("B")
+    ax.set_ylabel(r"$A(B, \bar{U}$)")
+
+fig, ax = plt.subplots()
+plot_indifference_curves(ax)
+```
+
+Note that in every case, if you increase either the number of apples or bananas (holding the other
+fixed), you reach a higher indifference curve.
+
+Consequently, in a world without scarcity or budgets, consumers would consume
+an arbitrarily high number of both to maximize their utility.
+
+#### Budget Constraints
+
+While the above example plots consumer preferences, it says nothing about what the consumers can afford.
+
+The simplest sort of constraint is a budget constraint where bananas and apples both have a price
+and the consumer has a limited amount of funds.
+
+If the prices per banana and per apple are identical, no matter how many you consume, then the
+affordable bundles are simply all pairs of apples and bananas below the line.
+$ p_a A + p_b B \leq W $.
+
+For example, if consumer has a budget of $ W $, the price of apples is $ p_A = 2 $ dollars per
+apple, and the price of bananas is normalized to be $ p_B = 1 $ dollar per banana, then the consumer
+can afford anything below the line.
+
+$$
+2 A + B \leq W
+$$
+
+Or, letting $ W = 20 $ and plotting
+
+```python
+def A_bc(B, W=20, pa=2):
+    "Given B, W, and pa return the max amount of A our consumer can afford"
+    return (W - B) / pa
+
+def plot_budget_constraint(ax, W=20, pa=2):
+    B_bc = np.array([0, W])
+    A = A_bc(B_bc, W, pa)
+    ax.plot(B_bc, A)
+    ax.fill_between(B_bc, 0, A, alpha=0.2)
+    ax.set_xlabel("B")
+    ax.set_ylabel("A")
+    return ax
+
+fig, ax = plt.subplots()
+plot_budget_constraint(ax, 20, 2)
+```
+
+While the consumer can afford any of the bundles in that area, most will not be optimal.
+
+#### Optimal Choice
+
+Putting the budget constraints and the utility functions together lets us visualize the optimal
+decision of a consumer. Choose the bundle with the highest possible indifference curve within its
+budget set.
+
+```python
+fig, ax = plt.subplots()
+plot_indifference_curves(ax)
+plot_budget_constraint(ax)
+```
+
+We have several ways to find the particular point $ A, B $ of maximum utility, such as
+finding the point where the indifference curve and the budget constraint have the same slope, but a
+simple approach is to just solve the direct maximization problem.
+
+$$
+\begin{aligned}
+\max_{A, B} & B^{\alpha}A^{1-\alpha}\\
+\text{s.t. } & p_A A + B \leq W
+\end{aligned}
+$$
+
+Solving this problem directly requires solving a multi-dimensional constrained optimization problem,
+where scipy [https://docs.scipy.org/doc/scipy/reference/tutorial/optimize.html#constrained-minimization-of-multivariate-scalar-functions-minimize](https://docs.scipy.org/doc/scipy/reference/tutorial/optimize.html#constrained-minimization-of-multivariate-scalar-functions-minimize)
+has several options.
+
+For this particular problem, we notice two things: (1) The utility function is increasing in both
+$ A $ and $ B $, and (2) there are only 2 goods.
+
+This allows us 1) to assume that the budget constraint holds at equality, $ p_a A + B = W $, 2) to
+form a new function $ A(B) = (W - B) / p_a $ by rearranging the budget constraint at equality, and
+3) to substitute that function directly to form:
+
+$$
+\max_{B}  B^{\alpha}A(B)^{1-\alpha}
+$$
+
+Compared to before, this problem has been turned into an unconstrained univariate optimization
+problem.
+
+To implement this in code, notice that the $ A(B) $ function is what we defined before
+as `A_bc`.
+
+We will solve this by using the function `scipy.optimize.minimize_scalar`, which takes a function
+`f(x)` and returns the value of `x` that minimizes `f`.
+
+```python
+from scipy.optimize import minimize_scalar
+
+def objective(B, W=20, pa=2):
+    """
+    Return value of -U for a given B, when we consume as much A as possible
+
+    Note that we return -U because scipy wants to minimize functions,
+    and the value of B that minimizes -U will maximize U
+    """
+    A = A_bc(B, W, pa)
+    return -U(A, B)
+
+result = minimize_scalar(objective)
+optimal_B = result.x
+optimal_A = A_bc(optimal_B, 20, 2)
+optimal_U = U(optimal_A, optimal_B)
+
+print("The optimal U is ", optimal_U)
+print("and was found at (A,B) =", (optimal_A, optimal_B))
+```
+
+This allows us to do experiments, such as examining how consumption patterns change as prices or
+wealth levels change.
+
+But First, Let's fix the graph!  
+Lets add UBar to the Set of Indifference Curves
+
+```python
+def A_indifference(B, ubar, alpha=1/3):
+    return ubar**(1/(1-alpha)) * B**(-alpha/(1-alpha))
+
+def plot_indifference_curves(ax, alpha=1/3):
+    ubar = np.arange(1, 11, 2)
+    ubar = np.append(ubar, optimal_U)
+    ax.plot(B, A_indifference(B, ubar, alpha))
+    ax.legend([r"$\bar{U}$" + " = {}".format(i) for i in ubar])
+    ax.set_xlabel("B")
+    ax.set_ylabel(r"$A(B, \bar{U}$)")
+
+fig, ax = plt.subplots()
+plot_indifference_curves(ax)
+```
+
+Then lets set the optimal level of consumpton of A and B
+and add them to the graph
+
+```python
+fig, ax = plt.subplots()
+plot_indifference_curves(ax)
+plot_budget_constraint(ax)
+ax.plot(optimal_B, optimal_A, 'go', label=f"Optimal Point (A, B) = ({optimal_A:.2f}, {optimal_B:.2f})")
+ax.annotate(f"({optimal_A:.2f}, {optimal_B:.2f})", (optimal_B, optimal_A),
+            textcoords="offset points", xytext=(5,5), ha='center')
+```
+
+```python
+
+```
+