my-markdown-library 0.1.0

data/F24Textbook_MD/04-production/shifts.md

@@ -0,0 +1,296 @@
+---
+title: shifts
+type: textbook
+source_path: content/04-production/shifts.ipynb
+chapter: 4
+---
+
+```python
+from textbook_utils import *
+```
+
+# Analyzing Shifts in $A$ and $\alpha$
+
+## Shifts in $A$ and their Effect on Output
+
+First, let us plot a 3D surface of the Cobb-Douglas production function. Output, $Y$ , will go on the vertical (or $z$ ) axis. Capital and labor will go on the $y$ and $x$ axes, resp. The plot below plots the Cobb-Douglas function with $A=2$, also showing $A=1$ for reference.
+
+[Following image is a 3D plot of Output increasing with Capital and Labor]
+
+```python
+#change_A(2, filename="fig1.html")
+display(HTML("fig1.html"))
+```
+
+Supply or total factor productivity shocks could cause $A$ to change. These occur if there is a change in total output for a given level of capital and labor. Examples of these include financial crises, technology shocks, natural environment/distasters and energy prices.
+
+[Following image is an interactive 3D plot of Output increasing with Capital and Labor as A changes]
+
+```python
+filename = "fig6.html"
+
+# L_s = np.arange(0, 10.11, 0.1)
+# K_s = np.arange(0, 10.11, 0.1)
+# alpha = 0.5
+# xx, yy = np.meshgrid(K_s, L_s)
+# # plot_cobb_douglas(curr_V, orig_cobb_douglas(), fr"A = {A}", r"A = 1", filename=filename)
+
+# layout = go.Layout(
+#     title = "Cobb-Douglas Production Function", autosize=False, width=500, height=500, margin = dict(l = 65, r = 50, b = 65, t = 90),
+#     scene = dict(xaxis = dict(title = 'K'), yaxis = dict(title = 'L'), zaxis = dict(title = 'Y'))
+# )
+
+# fig = go.Figure(layout = layout)
+
+# active = None
+# As = []
+# for i, A in enumerate(np.arange(0.5, 10.1, 0.5)):
+#     As.append(A)
+#     if A == 1:
+#         active = i
+#     V = cobb_douglas(A, xx, yy, alpha)
+#     fig.add_trace(go.Surface(
+#         z = V, contours = go.surface.Contours(
+#             z = go.surface.contours.Z(
+#                 show = False, project = dict(z = True)
+#             )
+#         ), colorscale = "Electric", showscale = False, name=f"A = {A}", visible=False
+#     ))
+    
+# fig.data[active].visible = True
+
+# steps = []
+# for i in range(len(fig.data)):
+#     step = dict(
+#         method="update", args=[
+#             {"visible": [False] * len(fig.data) + [True]},
+#         ], label=f"A = {As[i]}"
+#     )
+#     step["args"][0]["visible"][i] = True
+#     steps.append(step)
+    
+# sliders = [dict(
+#     active=active,
+#     currentvalue={"prefix": ""},
+#     pad={"t": 50},
+#     steps=steps
+# )]
+
+# fig.update_layout(sliders=sliders, width=500, height=600)
+
+# orig_V = orig_cobb_douglas()
+# fig.add_trace(go.Surface(
+#     z = orig_V, contours = go.surface.Contours(
+#         z = go.surface.contours.Z(
+#             show = False, project = dict(z = True)
+#         )
+#     ), colorscale = "Viridis", showscale = False, name="A = 1"
+# ))
+
+# plot(fig, filename=filename, auto_open=False, include_mathjax='cdn')
+
+display(HTML(filename))
+```
+
+Favorable shocks rotate the production function upward through an increase in A. Thus, each unit of input from capital and labor now simulataneously produce more output. What does this mean for the rental rate of capital and the real wage? Recall the functions for both of them:
+
+$$\begin{aligned}
+\text{MPL} &= A (1 - \alpha) \left ( \frac{K}{L} \right )^{\alpha} \\
+\text{MPK} &= \alpha A \left ( \frac{L}{K} \right )^{1 - \alpha} 
+\end{aligned}$$
+
+Both MPK and MPL will increase by a factor of $A$. Thus, it would be more expensive to hire an additional unit of labor or rent an additional unit of capital. As they are both more productive than previously, they are both more valuable to a business and thus will cost more. Negative shocks do the opposite. They rotate the production function downward through a decrease in $A$. Each unit of input is now less productive, meaning that both the rental rate of capital and the real wage are lower.
+
+## Shifts in $\alpha$ and their Effect on Output
+
+We will now plot what happens to the Cobb-Douglas function as we vary $\alpha$, while holding all other variables constant. The plot below shows $\alpha = 0.8$ (the purple-yellow surface) with $\alpha=0.5$ for reference (the blue-yellow surface). Try and hypothesize what this will do to our production function.
+
+[Following image is a 3D plot of Output increasing with Capital and Labor, with shifts as alpha changes]
+
+```python
+#change_alpha(0.8, filename="fig2.html")
+display(HTML("fig2.html"))
+```
+
+The next plot has $\alpha = 0.2$ (the purple-yellow surface) with $\alpha=0.5$ for reference (the blue-yellow surface). What is the difference between the plot above and the one below?
+
+[Following image is a 3D plot of Output increasing with Capital and Labor, with shifts as alpha changes]
+
+```python
+#change_alpha(0.3, filename="fig3.html")
+display(HTML("fig3.html"))
+```
+
+Below is an interactive plot with a slider to change $\alpha$. Try out different values and see how the shape of the production function changes.
+
+[Following image is an interactive 3D plot of Output increasing with Capital and Labor as alpha changes]
+
+```python
+filename = "fig7.html"
+
+# #L_s = np.arange(0, 10.11, 0.1)
+# K_s = np.arange(0, 10.11, 0.1)
+# A = 1
+# xx, yy = np.meshgrid(K_s, L_s)
+
+# layout = go.Layout(
+#     title = "Cobb-Douglas Production Function", autosize=False, width=500, height=500, margin = dict(l = 65, r = 50, b = 65, t = 90),
+#     scene = dict(xaxis = dict(title = 'K'), yaxis = dict(title = 'L'), zaxis = dict(title = 'Y'))
+# )
+
+# fig = go.Figure(layout = layout)
+
+# active = None
+# alphas = []
+# for i, alpha in enumerate(np.arange(0.1, 1.01, 0.1)):
+#     alphas.append(alpha)
+#     if alpha == 0.5:
+#         active = i
+#     V = cobb_douglas(A, xx, yy, alpha)
+#     fig.add_trace(go.Surface(
+#         z = V, contours = go.surface.Contours(
+#             z = go.surface.contours.Z(
+#                 show = False, project = dict(z = True)
+#             )
+#         ), colorscale = "Electric", showscale = False, name=f"alpha = {alpha}", visible=False
+#     ))
+    
+# fig.data[active].visible = True
+
+# steps = []
+# for i in range(len(fig.data)):
+#     step = dict(
+#         method="update", args=[
+#             {"visible": [False] * len(fig.data) + [True]},
+#         ], label=f"alpha = {alphas[i]}"
+#     )
+#     step["args"][0]["visible"][i] = True
+#     steps.append(step)
+    
+# sliders = [dict(
+#     active=active,
+#     currentvalue={"prefix": ""},
+#     pad={"t": 50},
+#     steps=steps
+# )]
+
+# fig.update_layout(sliders=sliders, width=500, height=600)
+
+# orig_V = orig_cobb_douglas()
+# fig.add_trace(go.Surface(
+#     z = orig_V, contours = go.surface.Contours(
+#         z = go.surface.contours.Z(
+#             show = False, project = dict(z = True)
+#         )
+#     ), colorscale = "Viridis", showscale = False, name="alpha = 0.5"
+# ))
+
+# plot(fig, filename=filename, auto_open=False, include_mathjax='cdn')
+
+display(HTML(filename))
+```
+
+$\alpha$ and $\beta$ are called the output elasticities of capital and labor, respectively. They measure the responsiveness of output to a change in the levels of either labor or capital, holding all else constant. This means that if $\alpha$ or $\beta$ were high, then any small increase in their respective input would lead to a relatively large increase in output. As an example, if $\alpha$ was 0.4, then a 1% increase in capital would lead to a 0.4% increase in output.
+
+Note, we assume that there are constant returns to scale. Thus, an increase in $\alpha$ necessarily means $\beta$ decreases. This reveals something important when comparing countries: the higher the $\alpha$, the more capital-intensive the country's production is. This means that $\alpha$ and $\beta$ give economists and policymakers insight as to how resources are allocated across nations.
+
+## Returns to Scale
+
+The significance of the exponents adding up to 1 ($\alpha + \beta = 1$) is that this implies constant returns to scale. If all inputs are scaled by a common non-zero factor, the output will be scaled by that same factor. Below is a generalization of this:
+
+$$\begin{aligned}
+Y &= A (c \cdot K)^\alpha (c \cdot L)^{1 - \alpha} \\
+&= A c^\alpha K ^ \alpha c^{1 - \alpha}L^{1 - \alpha} \\
+&= A c^{\alpha + 1 - \alpha}K^\alpha L^{1 - \alpha} \\
+&= c \cdot A K^\alpha L^{1 - \alpha}
+\end{aligned}$$
+
+Thus, any increase in either of the inputs will lead to a 1-1 increase in output. This is a significant assumption to make, as it essentially incentivizes companies to continue to "scale" their production inputs. They are not losing out on how much return is produced - they are getting output that matches exactly what they put into production.
+
+The alternative case is when $\alpha + \beta < 1$. This is called decreasing returns to scale, and occurs when a company scales their production inputs by a factor of c, but gets a scaling in output that is less than c.
+
+The last case is the most profitable one, when $\alpha + \beta > 1$. This is called increasing returns to scale, and occurs when a company increases their production inputs by c, but gets an increase in output that is greater than c.
+
+Let us visually examine how values of $\alpha$ and $\beta$ affect output.
+
+```python
+#change_alpha_beta(2, filename="fig4.html")
+display(HTML("fig4.html"))
+```
+
+The above graph shows increasing returns to scale with $\alpha + \beta = 2$ (the purble-yellow surface) with constant returns to scale for comparison (the blue-yellow surface). Notice how the orange function no longer increases at a decreasing rate, but seems to mimic exponential growth. This is once again because of the definition of increasing returns to scale. As companies continue to increase their inputs by a factor of $c$, they see their output increase by more than that factor. Thus, as inputs $(K, L)$ increase, output will increase at an even faster rate than that - in this case by the square.
+
+```python
+#change_alpha_beta(0.5, filename="fig5.html")
+display(HTML("fig5.html"))
+```
+
+The above graph exhibits decreasing returns to scale as $\alpha + \beta = 0.5$ (the purple-yellow surface) with constant returns to scale for comparison (the blue-yellow surface). This time, the orange production function flattens out far faster than the regular constant returns to scale function. You can prove this to yourself using the slider below, which adjusts the value of $\alpha + \beta$.
+
+```python
+filename = "fig8.html"
+
+# L_s = np.arange(0, 10.11, 0.1)
+# K_s = np.arange(0, 10.11, 0.1)
+# A = 1
+# xx, yy = np.meshgrid(K_s, L_s)
+
+# layout = go.Layout(
+#     title = "Cobb-Douglas Production Function", autosize=False, width=500, height=500, margin = dict(l = 65, r = 50, b = 65, t = 90),
+#     scene = dict(xaxis = dict(title = 'K'), yaxis = dict(title = 'L'), zaxis = dict(title = 'Y'))
+# )
+
+# fig = go.Figure(layout = layout)
+
+# active = None
+# default = 1
+# ab_sums = []
+# for i, ab_sum in enumerate(np.arange(0.1, 3.01, 0.1)):
+#     ab_sums.append(ab_sum)
+#     if ab_sum == default:
+#         active = i
+#     alpha, beta = ab_sum / 2, ab_sum / 2
+#     V = cobb_douglas(A, xx, yy, alpha, beta)
+#     fig.add_trace(go.Surface(
+#         z = V, contours = go.surface.Contours(
+#             z = go.surface.contours.Z(
+#                 show = False, project = dict(z = True)
+#             )
+#         ), colorscale = "Electric", showscale = False, name=f"alpha + beta = {ab_sum}", visible=False
+#     ))
+    
+# fig.data[active].visible = True
+
+# steps = []
+# for i in range(len(fig.data)):
+#     step = dict(
+#         method="update", args=[
+#             {"visible": [False] * len(fig.data) + [True]},
+#         ], label=f"alpha + beta = {ab_sums[i]}"
+#     )
+#     step["args"][0]["visible"][i] = True
+#     steps.append(step)
+    
+# sliders = [dict(
+#     active=active,
+#     currentvalue={"prefix": ""},
+#     pad={"t": 50},
+#     steps=steps
+# )]
+
+# fig.update_layout(sliders=sliders, width=500, height=600)
+
+# orig_V = orig_cobb_douglas()
+# fig.add_trace(go.Surface(
+#     z = orig_V, contours = go.surface.Contours(
+#         z = go.surface.contours.Z(
+#             show = False, project = dict(z = True)
+#         )
+#     ), colorscale = "Viridis", showscale = False, name=f"alpha + beta = {default}"
+# ))
+
+# plot(fig, filename=filename, auto_open=False, include_mathjax='cdn')
+
+display(HTML(filename))
+```
+

data/F24Textbook_MD/05-utility/budget-constraints.md

@@ -0,0 +1,166 @@
+---
+title: budget-constraints
+type: textbook
+source_path: content/05-utility/budget-constraints.ipynb
+chapter: 5
+---
+
+```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')
+```
+
+# 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$. 
+
+[Following image is s graph of a series of nested convex Indifference Curves with a budget constraint ]
+
+```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. 
+
+[Following image is s graph of a series of nested convex Indifference Curves with a budget constraint ]
+
+```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.
+
+[Following image is an interactive 3D plot of Utility increasing with X1 and X2, wih a plane representing the budget constraint]
+
+```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/F24Textbook_MD/05-utility/index.md

@@ -0,0 +1,15 @@
+---
+title: index
+type: textbook
+source_path: content/05-utility/index.md
+chapter: 5
+---
+
+# Utility
+
+**Student Learning Outcomes:**
+
+* Understand the basic principles of utility 
+* Become familiar with utility function such as the Cobb-Douglas utility function
+* Translate utility functions with 2 inputs to indifference curves
+* Understand budget constraints and how they affect utility maximization

data/F24Textbook_MD/05-utility/utility.md

@@ -0,0 +1,136 @@
+---
+title: utility
+type: textbook
+source_path: content/05-utility/utility.ipynb
+chapter: 5
+---
+
+```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')
+```
+
+# 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. 
+
+[Following image is an interactive 3D plot of Utility increasing with X1 and X2]
+
+```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. 
+
+[Following image is s graph of a series of nested convex Indifference Curves for different amounts of X1 and X2 ]
+
+```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"))
+```
+